file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.sample.deepsearchpicker/omni/sample/deepsearchpicker/tests/test_hello_world.py | # NOTE:
# omni.kit.test - std python's unittest module with additional wrapping to add suport for async/await tests
# For most things refer to unittest docs: https://docs.python.org/3/library/unittest.html
import omni.kit.test
# Extnsion for writing UI tests (simulate UI interaction)
import omni.kit.ui_test as ui_test
# Import extension python module we are testing with absolute import path, as if we are external user (other extension)
import company.hello.world
# Having a test class dervived from omni.kit.test.AsyncTestCase declared on the root of module will make it auto-discoverable by omni.kit.test
class Test(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
pass
# After running each test
async def tearDown(self):
pass
# Actual test, notice it is "async" function, so "await" can be used if needed
async def test_hello_public_function(self):
result = company.hello.world.some_public_function(4)
self.assertEqual(result, 256)
async def test_window_button(self):
# Find a label in our window
label = ui_test.find("My Window//Frame/**/Label[*]")
# Find buttons in our window
add_button = ui_test.find("My Window//Frame/**/Button[*].text=='Add'")
reset_button = ui_test.find("My Window//Frame/**/Button[*].text=='Reset'")
# Click reset button
await reset_button.click()
self.assertEqual(label.widget.text, "empty")
await add_button.click()
self.assertEqual(label.widget.text, "count: 1")
await add_button.click()
self.assertEqual(label.widget.text, "count: 2")
| 1,674 | Python | 34.638297 | 142 | 0.682198 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.sample.deepsearchpicker/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.0.0] - 2021-04-26
- Initial version of extension UI template with a window
| 178 | Markdown | 18.888887 | 80 | 0.702247 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.sample.deepsearchpicker/docs/README.md | # Simple UI Extension Template
The simplest python extension example. Use it as a starting point for your extensions.
| 119 | Markdown | 28.999993 | 86 | 0.806723 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.0.0"
# The title and description fields are primarily for displaying extension info in UI
title = "AI Room Generator Sample"
description="Generates Rooms using ChatGPT"
# Path (relative to the root) or content of readme markdown file for UI.
readme = "docs/README.md"
# URL of the extension source repository.
repository = ""
# One of categories for UI.
category = "Example"
# Keywords for the extension
keywords = ["kit", "example"]
# Icon to show in the extension manager
icon = "data/preview_icon.png"
# Preview to show in the extension manager
preview_image = "data/preview.png"
# Use omni.ui to build simple UI
[dependencies]
"omni.kit.uiapp" = {}
"omni.kit.ngsearch" = {}
"omni.kit.window.popup_dialog" = {}
# Main python module this extension provides, it will be publicly available as "import company.hello.world".
[[python.module]]
name = "omni.example.airoomgenerator"
[[test]]
# Extra dependencies only to be used during test run
dependencies = [
"omni.kit.ui_test" # UI testing extension
]
| 1,091 | TOML | 24.999999 | 108 | 0.731439 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/priminfo.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from pxr import Usd, Gf
class PrimInfo:
# Class that stores the prim info
def __init__(self, prim: Usd.Prim, name: str = "") -> None:
self.prim = prim
self.child = prim.GetAllChildren()[0]
self.length = self.GetLengthOfPrim()
self.width = self.GetWidthOfPrim()
self.origin = self.GetPrimOrigin()
self.area_name = name
def GetLengthOfPrim(self) -> str:
# Returns the X value
attr = self.child.GetAttribute('xformOp:scale')
x_scale = attr.Get()[0]
return str(x_scale)
def GetWidthOfPrim(self) -> str:
# Returns the Z value
attr = self.child.GetAttribute('xformOp:scale')
z_scale = attr.Get()[2]
return str(z_scale)
def GetPrimOrigin(self) -> str:
attr = self.prim.GetAttribute('xformOp:translate')
origin = Gf.Vec3d(0,0,0)
if attr:
origin = attr.Get()
phrase = str(origin[0]) + ", " + str(origin[1]) + ", " + str(origin[2])
return phrase | 1,706 | Python | 36.108695 | 98 | 0.651817 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/widgets.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import omni.ui as ui
from omni.ui import color as cl
import asyncio
import omni
import carb
class ProgressBar:
def __init__(self):
self.progress_bar_window = None
self.left = None
self.right = None
self._build_fn()
async def play_anim_forever(self):
fraction = 0.0
while True:
fraction = (fraction + 0.01) % 1.0
self.left.width = ui.Fraction(fraction)
self.right.width = ui.Fraction(1.0-fraction)
await omni.kit.app.get_app().next_update_async()
def _build_fn(self):
with ui.VStack():
self.progress_bar_window = ui.HStack(height=0, visible=False)
with self.progress_bar_window:
ui.Label("Processing", width=0, style={"margin_width": 3})
self.left = ui.Spacer(width=ui.Fraction(0.0))
ui.Rectangle(width=50, style={"background_color": cl("#76b900")})
self.right = ui.Spacer(width=ui.Fraction(1.0))
def show_bar(self, to_show):
self.progress_bar_window.visible = to_show
| 1,770 | Python | 34.419999 | 98 | 0.655367 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/chatgpt_apiconnect.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
import carb
import aiohttp
import asyncio
from .prompts import system_input, user_input, assistant_input
from .deep_search import query_items
from .item_generator import place_greyboxes, place_deepsearch_results
async def chatGPT_call(prompt: str):
# Load your API key from an environment variable or secret management service
settings = carb.settings.get_settings()
apikey = settings.get_as_string("/persistent/exts/omni.example.airoomgenerator/APIKey")
my_prompt = prompt.replace("\n", " ")
# Send a request API
try:
parameters = {
"model": "gpt-3.5-turbo",
"messages": [
{"role": "system", "content": system_input},
{"role": "user", "content": user_input},
{"role": "assistant", "content": assistant_input},
{"role": "user", "content": my_prompt}
]
}
chatgpt_url = "https://api.openai.com/v1/chat/completions"
headers = {"Authorization": "Bearer %s" % apikey}
# Create a completion using the chatGPT model
async with aiohttp.ClientSession() as session:
async with session.post(chatgpt_url, headers=headers, json=parameters) as r:
response = await r.json()
text = response["choices"][0]["message"]['content']
except Exception as e:
carb.log_error("An error as occurred")
return None, str(e)
# Parse data that was given from API
try:
#convert string to object
data = json.loads(text)
except ValueError as e:
carb.log_error(f"Exception occurred: {e}")
return None, text
else:
# Get area_objects_list
object_list = data['area_objects_list']
return object_list, text
async def call_Generate(prim_info, prompt, use_chatgpt, use_deepsearch, response_label, progress_widget):
run_loop = asyncio.get_event_loop()
progress_widget.show_bar(True)
task = run_loop.create_task(progress_widget.play_anim_forever())
response = ""
#chain the prompt
area_name = prim_info.area_name.split("/World/Layout/")
concat_prompt = area_name[-1].replace("_", " ") + ", " + prim_info.length + "x" + prim_info.width + ", origin at (0.0, 0.0, 0.0), generate a list of appropriate items in the correct places. " + prompt
root_prim_path = "/World/Layout/GPT/"
if prim_info.area_name != "":
root_prim_path= prim_info.area_name + "/items/"
if use_chatgpt: #when calling the API
objects, response = await chatGPT_call(concat_prompt)
else: #when testing and you want to skip the API call
data = json.loads(assistant_input)
objects = data['area_objects_list']
if objects is None:
response_label.text = response
return
if use_deepsearch:
settings = carb.settings.get_settings()
nucleus_path = settings.get_as_string("/persistent/exts/omni.example.airoomgenerator/deepsearch_nucleus_path")
filter_path = settings.get_as_string("/persistent/exts/omni.example.airoomgenerator/filter_path")
filter_paths = filter_path.split(',')
queries = list()
for item in objects:
queries.append(item['object_name'])
query_result = await query_items(queries=queries, url=nucleus_path, paths=filter_paths)
if query_result is not None:
place_deepsearch_results(
gpt_results=objects,
query_result=query_result,
root_prim_path=root_prim_path)
else:
place_greyboxes(
gpt_results=objects,
root_prim_path=root_prim_path)
else:
place_greyboxes(
gpt_results=objects,
root_prim_path=root_prim_path)
task.cancel()
await asyncio.sleep(1)
response_label.text = response
progress_widget.show_bar(False)
| 4,729 | Python | 39.775862 | 204 | 0.623176 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/style.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import omni.ui as ui
from pathlib import Path
icons_path = Path(__file__).parent.parent.parent.parent / "icons"
gen_ai_style = {
"HStack": {
"margin": 3
},
"Button.Image::create": {"image_url": f"{icons_path}/plus.svg", "color": 0xFF00B976},
"Button.Image::properties": {"image_url": f"{icons_path}/cog.svg", "color": 0xFF989898},
"Line": {
"margin": 3
},
"Label": {
"margin_width": 5
}
}
guide = """
Step 1: Create a Floor
- You can draw a floor outline using the pencil tool. Right click in the viewport then `Create>BasicCurves>From Pencil`
- OR Create a prim and scale it to the size you want. i.e. Right click in the viewport then `Create>Mesh>Cube`.
- Next, with the floor selected type in a name into "Area Name". Make sure the area name is relative to the room you want to generate.
For example, if you inputted the name as "bedroom" ChatGPT will be prompted that the room is a bedroom.
- Then click the '+' button. This will generate the floor and add the option to our combo box.
Step 2: Prompt
- Type in a prompt that you want to send along to ChatGPT. This can be information about what is inside of the room.
For example, "generate a comfortable reception area that contains a front desk and an area for guest to sit down".
Step 3: Generate
- Select 'use ChatGPT' if you want to recieve a response from ChatGPT otherwise it will use a premade response.
- Select 'use Deepsearch' if you want to use the deepsearch functionality. (ENTERPRISE USERS ONLY)
When deepsearch is false it will spawn in cubes that greybox the scene.
- Hit Generate, after hitting generate it will start making the appropriate calls. Loading bar will be shown as api-calls are being made.
Step 4: More Rooms
- To add another room you can repeat Steps 1-3. To regenerate a previous room just select it from the 'Current Room' in the dropdown menu.
- The dropdown menu will remember the last prompt you used to generate the items.
- If you do not like the items it generated, you can hit the generate button until you are satisfied with the items.
""" | 2,792 | Python | 45.549999 | 138 | 0.731734 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/prompts.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
system_input='''You are an area generator expert. Given an area of a certain size, you can generate a list of items that are appropriate to that area, in the right place, and with a representative material.
You operate in a 3D Space. You work in a X,Y,Z coordinate system. X denotes width, Y denotes height, Z denotes depth. 0.0,0.0,0.0 is the default space origin.
You receive from the user the name of the area, the size of the area on X and Z axis in centimetres, the origin point of the area (which is at the center of the area).
You answer by only generating JSON files that contain the following information:
- area_name: name of the area
- X: coordinate of the area on X axis
- Y: coordinate of the area on Y axis
- Z: coordinate of the area on Z axis
- area_size_X: dimension in cm of the area on X axis
- area_size_Z: dimension in cm of the area on Z axis
- area_objects_list: list of all the objects in the area
For each object you need to store:
- object_name: name of the object
- X: coordinate of the object on X axis
- Y: coordinate of the object on Y axis
- Z: coordinate of the object on Z axis
- Length: dimension in cm of the object on X axis
- Width: dimension in cm of the object on Y axis
- Height: dimension in cm of the object on Z axis
- Material: a reasonable material of the object using an exact name from the following list: Plywood, Leather_Brown, Leather_Pumpkin, Leather_Black, Aluminum_Cast, Birch, Beadboard, Cardboard, Cloth_Black, Cloth_Gray, Concrete_Polished, Glazed_Glass, CorrugatedMetal, Cork, Linen_Beige, Linen_Blue, Linen_White, Mahogany, MDF, Oak, Plastic_ABS, Steel_Carbon, Steel_Stainless, Veneer_OU_Walnut, Veneer_UX_Walnut_Cherry, Veneer_Z5_Maple.
Each object name should include an appropriate adjective.
Keep in mind, objects should be disposed in the area to create the most meaningful layout possible, and they shouldn't overlap.
All objects must be within the bounds of the area size; Never place objects further than 1/2 the length or 1/2 the depth of the area from the origin.
Also keep in mind that the objects should be disposed all over the area in respect to the origin point of the area, and you can use negative values as well to display items correctly, since origin of the area is always at the center of the area.
Remember, you only generate JSON code, nothing else. It's very important.
'''
user_input="Warehouse, 1000x1000, origin at (0.0,0.0,0.0), generate a list of appropriate items in the correct places. Generate warehouse objects"
assistant_input='''{
"area_name": "Warehouse_Area",
"X": 0.0,
"Y": 0.0,
"Z": 0.0,
"area_size_X": 1000,
"area_size_Z": 1000,
"area_objects_list": [
{
"object_name": "Parts_Pallet_1",
"X": -150,
"Y": 0.0,
"Z": 250,
"Length": 100,
"Width": 100,
"Height": 10,
"Material": "Plywood"
},
{
"object_name": "Boxes_Pallet_2",
"X": -150,
"Y": 0.0,
"Z": 150,
"Length": 100,
"Width": 100,
"Height": 10,
"Material": "Plywood"
},
{
"object_name": "Industrial_Storage_Rack_1",
"X": -150,
"Y": 0.0,
"Z": 50,
"Length": 200,
"Width": 50,
"Height": 300,
"Material": "Steel_Carbon"
},
{
"object_name": "Empty_Pallet_3",
"X": -150,
"Y": 0.0,
"Z": -50,
"Length": 100,
"Width": 100,
"Height": 10,
"Material": "Plywood"
},
{
"object_name": "Yellow_Forklift_1",
"X": 50,
"Y": 0.0,
"Z": -50,
"Length": 200,
"Width": 100,
"Height": 250,
"Material": "Plastic_ABS"
},
{
"object_name": "Heavy_Duty_Forklift_2",
"X": 150,
"Y": 0.0,
"Z": -50,
"Length": 200,
"Width": 100,
"Height": 250,
"Material": "Steel_Stainless"
}
]
}'''
| 4,898 | Python | 37.880952 | 435 | 0.612903 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/extension.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import omni.ext
from .window import GenAIWindow
# Any class derived from `omni.ext.IExt` in top level module (defined in `python.modules` of `extension.toml`) will be
# instantiated when extension gets enabled and `on_startup(ext_id)` will be called. Later when extension gets disabled
# on_shutdown() is called.
class MyExtension(omni.ext.IExt):
# ext_id is current extension id. It can be used with extension manager to query additional information, like where
# this extension is located on filesystem.
def on_startup(self, ext_id):
self._window = GenAIWindow("Generate Room", width=400, height=525)
def on_shutdown(self):
self._window.destroy()
self._window = None
| 1,399 | Python | 44.161289 | 119 | 0.742673 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/__init__.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from .extension import *
| 705 | Python | 40.529409 | 98 | 0.770213 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/materials.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
MaterialPresets = {
"Leather_Brown":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Leather_Brown.mdl',
"Leather_Pumpkin_01":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Leather_Pumpkin.mdl',
"Leather_Brown_02":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Leather_Brown.mdl',
"Leather_Black_01":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Leather_Black.mdl',
"Aluminum_cast":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Metals/Aluminum_Cast.mdl',
"Birch":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Wood/Birch.mdl',
"Beadboard":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Wood/Beadboard.mdl',
"Cardboard":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Wall_Board/Cardboard.mdl',
"Cloth_Black":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Cloth_Black.mdl',
"Cloth_Gray":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Cloth_Gray.mdl',
"Concrete_Polished":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Masonry/Concrete_Polished.mdl',
"Glazed_Glass":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Glass/Glazed_Glass.mdl',
"CorrugatedMetal":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Metals/CorrugatedMetal.mdl',
"Cork":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Wood/Cork.mdl',
"Linen_Beige":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Linen_Beige.mdl',
"Linen_Blue":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Linen_Blue.mdl',
"Linen_White":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Textiles/Linen_White.mdl',
"Mahogany":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Wood/Mahogany.mdl',
"MDF":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Wall_Board/MDF.mdl',
"Oak":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Wood/Oak.mdl',
"Plastic_ABS":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Plastics/Plastic_ABS.mdl',
"Steel_Carbon":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Metals/Steel_Carbon.mdl',
"Steel_Stainless":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Metals/Steel_Stainless.mdl',
"Veneer_OU_Walnut":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Plastics/Veneer_OU_Walnut.mdl',
"Veneer_UX_Walnut_Cherry":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Plastics/Veneer_UX_Walnut_Cherry.mdl',
"Veneer_Z5_Maple":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Plastics/Veneer_Z5_Maple.mdl',
"Plywood":
'http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Wood/Plywood.mdl',
"Concrete_Rough_Dirty":
'http://omniverse-content-production.s3.us-west-2.amazonaws.com/Materials/vMaterials_2/Concrete/Concrete_Rough.mdl'
} | 4,323 | Python | 58.232876 | 121 | 0.743234 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/utils.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import omni.kit.commands
from pxr import Gf, Sdf, UsdGeom
from .materials import *
import carb
def CreateCubeFromCurve(curve_path: str, area_name: str = ""):
ctx = omni.usd.get_context()
stage = ctx.get_stage()
min_coords, max_coords = get_coords_from_bbox(curve_path)
x,y,z = get_bounding_box_dimensions(curve_path)
xForm_scale = Gf.Vec3d(x, 1, z)
cube_scale = Gf.Vec3d(0.01, 0.01, 0.01)
prim = stage.GetPrimAtPath(curve_path)
origin = prim.GetAttribute('xformOp:translate').Get()
if prim.GetTypeName() == "BasisCurves":
origin = Gf.Vec3d(min_coords[0]+x/2, 0, min_coords[2]+z/2)
area_path = '/World/Layout/Area'
if len(area_name) != 0:
area_path = '/World/Layout/' + area_name.replace(" ", "_")
new_area_path = omni.usd.get_stage_next_free_path(stage, area_path, False)
new_cube_xForm_path = new_area_path + "/" + "Floor"
new_cube_path = new_cube_xForm_path + "/" + "Cube"
# Create xForm to hold all items
item_container = create_prim(new_area_path)
set_transformTRS_attrs(item_container, translate=origin)
# Create Scale Xform for floor
xform = create_prim(new_cube_xForm_path)
set_transformTRS_attrs(xform, scale=xForm_scale)
# Create Floor Cube
omni.kit.commands.execute('CreateMeshPrimWithDefaultXform',
prim_type='Cube',
prim_path=new_cube_path,
select_new_prim=True
)
cube = stage.GetPrimAtPath(new_cube_path)
set_transformTRS_attrs(cube, scale=cube_scale)
cube.CreateAttribute("primvar:area_name", Sdf.ValueTypeNames.String, custom=True).Set(area_name)
omni.kit.commands.execute('DeletePrims',
paths=[curve_path],
destructive=False)
apply_material_to_prim('Concrete_Rough_Dirty', new_area_path)
return new_area_path
def apply_material_to_prim(material_name: str, prim_path: str):
ctx = omni.usd.get_context()
stage = ctx.get_stage()
looks_path = '/World/Looks/'
mat_path = looks_path + material_name
mat_prim = stage.GetPrimAtPath(mat_path)
if MaterialPresets.get(material_name, None) is not None:
if not mat_prim.IsValid():
omni.kit.commands.execute('CreateMdlMaterialPrimCommand',
mtl_url=MaterialPresets[material_name],
mtl_name=material_name,
mtl_path=mat_path)
omni.kit.commands.execute('BindMaterialCommand',
prim_path=prim_path,
material_path=mat_path)
def create_prim(prim_path, prim_type='Xform'):
ctx = omni.usd.get_context()
stage = ctx.get_stage()
prim = stage.DefinePrim(prim_path)
if prim_type == 'Xform':
xform = UsdGeom.Xform.Define(stage, prim_path)
else:
xform = UsdGeom.Cube.Define(stage, prim_path)
create_transformOps_for_xform(xform)
return prim
def create_transformOps_for_xform(xform):
xform.AddTranslateOp()
xform.AddRotateXYZOp()
xform.AddScaleOp()
def set_transformTRS_attrs(prim, translate: Gf.Vec3d = Gf.Vec3d(0,0,0), rotate: Gf.Vec3d=Gf.Vec3d(0,0,0), scale: Gf.Vec3d=Gf.Vec3d(1,1,1)):
prim.GetAttribute('xformOp:translate').Set(translate)
prim.GetAttribute('xformOp:rotateXYZ').Set(rotate)
prim.GetAttribute('xformOp:scale').Set(scale)
def get_bounding_box_dimensions(prim_path: str):
min_coords, max_coords = get_coords_from_bbox(prim_path)
length = max_coords[0] - min_coords[0]
width = max_coords[1] - min_coords[1]
height = max_coords[2] - min_coords[2]
return length, width, height
def get_coords_from_bbox(prim_path: str):
ctx = omni.usd.get_context()
bbox = ctx.compute_path_world_bounding_box(prim_path)
min_coords, max_coords = bbox
return min_coords, max_coords
def scale_object_if_needed(prim_path):
stage = omni.usd.get_context().get_stage()
length, width, height = get_bounding_box_dimensions(prim_path)
largest_dimension = max(length, width, height)
if largest_dimension < 10:
prim = stage.GetPrimAtPath(prim_path)
# HACK: All Get Attribute Calls need to check if the attribute exists and add it if it doesn't
if prim.IsValid():
scale_attr = prim.GetAttribute('xformOp:scale')
if scale_attr.IsValid():
current_scale = scale_attr.Get()
new_scale = (current_scale[0] * 100, current_scale[1] * 100, current_scale[2] * 100)
scale_attr.Set(new_scale)
carb.log_info(f"Scaled object by 100 times: {prim_path}")
else:
carb.log_info(f"Scale attribute not found for prim at path: {prim_path}")
else:
carb.log_info(f"Invalid prim at path: {prim_path}")
else:
carb.log_info(f"No scaling needed for object: {prim_path}") | 5,463 | Python | 38.594203 | 139 | 0.663738 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/deep_search.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from omni.kit.ngsearch.client import NGSearchClient
import asyncio
import carb
async def query_items(queries, url: str, paths):
result = list(tuple())
for query in queries:
query_result = await _query_first(query, url, paths)
if query_result is not None:
result.append(query_result)
return result
async def _query_first(query: str, url: str, paths):
filtered_query = "ext:usd,usdz,usda "
if len(paths) > 0:
filtered_query = filtered_query + " path: "
for path in paths:
filtered_query = filtered_query + "\"" + str(path) + "\","
filtered_query = filtered_query[:-1]
filtered_query = filtered_query + " "
filtered_query = filtered_query + query
search_result = await NGSearchClient.get_instance().find2(
query=filtered_query, url=url)
if search_result is not None:
if len(search_result.paths) > 0:
return (query, search_result.paths[0].uri)
else:
carb.log_warn(f"Search Results came up with nothing for {query}. Make sure you've configured your nucleus path")
return None
async def query_all(query: str, url: str, paths):
filtered_query = "ext:usd,usdz,usda " + query
return await NGSearchClient.get_instance().find2(query=filtered_query, url=url)
| 2,043 | Python | 31.967741 | 120 | 0.67303 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/item_generator.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#hotkey
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from pxr import Usd, Sdf, Gf
from .utils import scale_object_if_needed, apply_material_to_prim, create_prim, set_transformTRS_attrs
def place_deepsearch_results(gpt_results, query_result, root_prim_path):
index = 0
for item in query_result:
item_name = item[0]
item_path = item[1]
# Define Prim
prim_parent_path = root_prim_path + item_name.replace(" ", "_")
prim_path = prim_parent_path + "/" + item_name.replace(" ", "_")
parent_prim = create_prim(prim_parent_path)
next_prim = create_prim(prim_path)
# Add reference to USD Asset
references: Usd.references = next_prim.GetReferences()
# TODO: The query results should returnt he full path of the prim
references.AddReference(
assetPath="omniverse://ov-simready" + item_path)
# Add reference for future search refinement
config = next_prim.CreateAttribute("DeepSearch:Query", Sdf.ValueTypeNames.String)
config.Set(item_name)
# HACK: All "GetAttribute" calls should need to check if the attribute exists
# translate prim
next_object = gpt_results[index]
index = index + 1
x = next_object['X']
y = next_object['Y']
z = next_object['Z']
set_transformTRS_attrs(parent_prim, Gf.Vec3d(x,y,z), Gf.Vec3d(0,-90,-90), Gf.Vec3d(1.0,1.0,1.0))
scale_object_if_needed(prim_parent_path)
def place_greyboxes(gpt_results, root_prim_path):
index = 0
for item in gpt_results:
# Define Prim
prim_parent_path = root_prim_path + item['object_name'].replace(" ", "_")
prim_path = prim_parent_path + "/" + item['object_name'].replace(" ", "_")
# Define Dimensions and material
length = item['Length']/100
width = item['Width']/100
height = item['Height']/100
x = item['X']
y = item['Y']+height*100*.5 #shift bottom of object to y=0
z = item['Z']
material = item['Material']
# Create Prim
parent_prim = create_prim(prim_parent_path)
set_transformTRS_attrs(parent_prim)
prim = create_prim(prim_path, 'Cube')
set_transformTRS_attrs(prim, translate=Gf.Vec3d(x,y,z), scale=Gf.Vec3d(length, height, width))
prim.GetAttribute('extent').Set([(-50.0, -50.0, -50.0), (50.0, 50.0, 50.0)])
prim.GetAttribute('size').Set(100)
index = index + 1
# Add Attribute and Material
attr = prim.CreateAttribute("object_name", Sdf.ValueTypeNames.String)
attr.Set(item['object_name'])
apply_material_to_prim(material, prim_path)
| 3,365 | Python | 38.139534 | 104 | 0.63477 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/window.py | # SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import omni.ui as ui
import omni.usd
import carb
import asyncio
import omni.kit.commands
from omni.kit.window.popup_dialog.form_dialog import FormDialog
from .utils import CreateCubeFromCurve
from .style import gen_ai_style, guide
from .chatgpt_apiconnect import call_Generate
from .priminfo import PrimInfo
from pxr import Sdf
from .widgets import ProgressBar
class GenAIWindow(ui.Window):
def __init__(self, title: str, **kwargs) -> None:
super().__init__(title, **kwargs)
# Models
self._path_model = ui.SimpleStringModel()
self._prompt_model = ui.SimpleStringModel("generate warehouse objects")
self._area_name_model = ui.SimpleStringModel()
self._use_deepsearch = ui.SimpleBoolModel()
self._use_chatgpt = ui.SimpleBoolModel()
self._areas = []
self.response_log = None
self.current_index = -1
self.current_area = None
self._combo_changed_sub = None
self.frame.set_build_fn(self._build_fn)
def _build_fn(self):
with self.frame:
with ui.ScrollingFrame():
with ui.VStack(style=gen_ai_style):
with ui.HStack(height=0):
ui.Label("Content Generatation with ChatGPT", style={"font_size": 18})
ui.Button(name="properties", tooltip="Configure API Key and Nucleus Path", width=30, height=30, clicked_fn=lambda: self._open_settings())
with ui.CollapsableFrame("Getting Started Instructions", height=0, collapsed=True):
ui.Label(guide, word_wrap=True)
ui.Line()
with ui.HStack(height=0):
ui.Label("Area Name", width=ui.Percent(30))
ui.StringField(model=self._area_name_model)
ui.Button(name="create", width=30, height=30, clicked_fn=lambda: self._create_new_area(self.get_area_name()))
with ui.HStack(height=0):
ui.Label("Current Room", width=ui.Percent(30))
self._build_combo_box()
ui.Line()
with ui.HStack(height=ui.Percent(50)):
ui.Label("Prompt", width=0)
ui.StringField(model=self._prompt_model, multiline=True)
ui.Line()
self._build_ai_section()
def _save_settings(self, dialog):
values = dialog.get_values()
carb.log_info(values)
settings = carb.settings.get_settings()
settings.set_string("/persistent/exts/omni.example.airoomgenerator/APIKey", values["APIKey"])
settings.set_string("/persistent/exts/omni.example.airoomgenerator/deepsearch_nucleus_path", values["deepsearch_nucleus_path"])
settings.set_string("/persistent/exts/omni.example.airoomgenerator/path_filter", values["path_filter"])
dialog.hide()
def _open_settings(self):
settings = carb.settings.get_settings()
apikey_value = settings.get_as_string("/persistent/exts/omni.example.airoomgenerator/APIKey")
nucleus_path = settings.get_as_string("/persistent/exts/omni.example.airoomgenerator/deepsearch_nucleus_path")
path_filter = settings.get_as_string("/persistent/exts/omni.example.airoomgenerator/path_filter")
if apikey_value == "":
apikey_value = "Enter API Key Here"
if nucleus_path == "":
nucleus_path = "(ENTERPRISE ONLY) Enter Nucleus Path Here"
if path_filter == "":
path_filter = ""
field_defs = [
FormDialog.FieldDef("APIKey", "API Key: ", ui.StringField, apikey_value),
FormDialog.FieldDef("deepsearch_nucleus_path", "Nucleus Path: ", ui.StringField, nucleus_path),
FormDialog.FieldDef("path_filter", "Path Filter: ", ui.StringField, path_filter)
]
dialog = FormDialog(
title="Settings",
message="Your Settings: ",
field_defs = field_defs,
ok_handler=lambda dialog: self._save_settings(dialog))
dialog.show()
def _build_ai_section(self):
with ui.HStack(height=0):
ui.Spacer()
ui.Label("Use ChatGPT: ")
ui.CheckBox(model=self._use_chatgpt)
ui.Label("Use Deepsearch: ", tooltip="ENTERPRISE USERS ONLY")
ui.CheckBox(model=self._use_deepsearch)
ui.Spacer()
with ui.HStack(height=0):
ui.Spacer(width=ui.Percent(10))
ui.Button("Generate", height=40,
clicked_fn=lambda: self._generate())
ui.Spacer(width=ui.Percent(10))
self.progress = ProgressBar()
with ui.CollapsableFrame("ChatGPT Response / Log", height=0, collapsed=True):
self.response_log = ui.Label("", word_wrap=True)
def _build_combo_box(self):
self.combo_model = ui.ComboBox(self.current_index, *[str(x) for x in self._areas] ).model
def combo_changed(item_model, item):
index_value_model = item_model.get_item_value_model(item)
self.current_area = self._areas[index_value_model.as_int]
self.current_index = index_value_model.as_int
self.rebuild_frame()
self._combo_changed_sub = self.combo_model.subscribe_item_changed_fn(combo_changed)
def _create_new_area(self, area_name: str):
if area_name == "":
carb.log_warn("No area name provided")
return
new_area_name = CreateCubeFromCurve(self.get_prim_path(), area_name)
self._areas.append(new_area_name)
self.current_index = len(self._areas) - 1
index_value_model = self.combo_model.get_item_value_model()
index_value_model.set_value(self.current_index)
def rebuild_frame(self):
# we do want to update the area name and possibly last prompt?
area_name = self.current_area.split("/World/Layout/")
self._area_name_model.set_value(area_name[-1].replace("_", " "))
attr_prompt = self.get_prim().GetAttribute('genai:prompt')
if attr_prompt.IsValid():
self._prompt_model.set_value(attr_prompt.Get())
else:
self._prompt_model.set_value("")
self.frame.rebuild()
def _generate(self):
prim = self.get_prim()
attr = prim.GetAttribute('genai:prompt')
if not attr.IsValid():
attr = prim.CreateAttribute('genai:prompt', Sdf.ValueTypeNames.String)
attr.Set(self.get_prompt())
items_path = self.current_area + "/items"
ctx = omni.usd.get_context()
stage = ctx.get_stage()
if stage.GetPrimAtPath(items_path).IsValid():
omni.kit.commands.execute('DeletePrims',
paths=[items_path],
destructive=False)
# asyncio.ensure_future(self.progress.fill_bar(0,100))
run_loop = asyncio.get_event_loop()
run_loop.create_task(call_Generate(self.get_prim_info(),
self.get_prompt(),
self._use_chatgpt.as_bool,
self._use_deepsearch.as_bool,
self.response_log,
self.progress
))
# Returns a PrimInfo object containing the Length, Width, Origin and Area Name
def get_prim_info(self) -> PrimInfo:
prim = self.get_prim()
prim_info = None
if prim.IsValid():
prim_info = PrimInfo(prim, self.current_area)
return prim_info
# # Get the prim path specified
def get_prim_path(self):
ctx = omni.usd.get_context()
selection = ctx.get_selection().get_selected_prim_paths()
if len(selection) > 0:
return str(selection[0])
carb.log_warn("No Prim Selected")
return ""
# Get the area name specified
def get_area_name(self):
if self._area_name_model == "":
carb.log_warn("No Area Name Provided")
return self._area_name_model.as_string
# Get the prompt specified
def get_prompt(self):
if self._prompt_model == "":
carb.log_warn("No Prompt Provided")
return self._prompt_model.as_string
# Get the prim based on the Prim Path
def get_prim(self):
ctx = omni.usd.get_context()
stage = ctx.get_stage()
prim = stage.GetPrimAtPath(self.current_area)
if prim.IsValid() is None:
carb.log_warn("No valid prim in the scene")
return prim
def destroy(self):
super().destroy()
self._combo_changed_sub = None
self._path_model = None
self._prompt_model = None
self._area_name_model = None
self._use_deepsearch = None
self._use_chatgpt = None | 9,607 | Python | 41.892857 | 161 | 0.595503 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/tests/__init__.py | from .test_hello_world import * | 31 | Python | 30.999969 | 31 | 0.774194 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/omni/example/airoomgenerator/tests/test_hello_world.py | # NOTE:
# omni.kit.test - std python's unittest module with additional wrapping to add suport for async/await tests
# For most things refer to unittest docs: https://docs.python.org/3/library/unittest.html
import omni.kit.test
# Extnsion for writing UI tests (simulate UI interaction)
import omni.kit.ui_test as ui_test
# Import extension python module we are testing with absolute import path, as if we are external user (other extension)
import company.hello.world
# Having a test class dervived from omni.kit.test.AsyncTestCase declared on the root of module will make it auto-discoverable by omni.kit.test
class Test(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
pass
# After running each test
async def tearDown(self):
pass
# Actual test, notice it is "async" function, so "await" can be used if needed
async def test_hello_public_function(self):
result = company.hello.world.some_public_function(4)
self.assertEqual(result, 256)
async def test_window_button(self):
# Find a label in our window
label = ui_test.find("My Window//Frame/**/Label[*]")
# Find buttons in our window
add_button = ui_test.find("My Window//Frame/**/Button[*].text=='Add'")
reset_button = ui_test.find("My Window//Frame/**/Button[*].text=='Reset'")
# Click reset button
await reset_button.click()
self.assertEqual(label.widget.text, "empty")
await add_button.click()
self.assertEqual(label.widget.text, "count: 1")
await add_button.click()
self.assertEqual(label.widget.text, "count: 2")
| 1,674 | Python | 34.638297 | 142 | 0.682198 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.0.0] - 2021-04-26
- Initial version of extension UI template with a window
| 178 | Markdown | 18.888887 | 80 | 0.702247 |
NVIDIA-Omniverse/kit-extension-sample-airoomgenerator/exts/omni.example.airoomgenerator/docs/README.md | # AI Room Generator Sample Extension (omni.sample.airoomgenerator)
## Overview
The AI Room Generator Sample Extension allows users to generate 3D content to populate a room using Generative AI. The user will specify what area that defines the room and a prompt that will get passed to ChatGPT.
> NOTE: To enable the extension you will need to have ngsearch module. By default it is already avaliable in Omniverse USD Composer. If using Omniverse Code follow these [instructions](https://docs.omniverse.nvidia.com/prod_nucleus/prod_services/services/deepsearch/client/using_deepsearch_ui.html#using-deepsearch-beta-in-usd-composer) to get ngsearch
This Sample Extension utilizes Omniverse's [Deepsearch](https://docs.omniverse.nvidia.com/prod_nucleus/prod_services/services/deepsearch/overview.html) functionality to search for models within a nucleus server. (ENTERPRISE USERS ONLY)
## UI Overview
1. Settings (Cog Button)
- Where the user can input their API Key from [OpenAI](https://platform.openai.com/account/api-keys)
- Enterprise users can input their Deepsearch Enabled Nucleus Path
2. Area Name
- The name that will be applied to the Area once added.
3. Add Area (Plus Button)
- With an area selected and an Area Name provided, it will remove the selected object and spawn in a cube resembling the dimensions of the selected area prim.
4. Current Room
- By default this will be empty. As you add rooms this combo box will populate and allow you to switch between each generated room maintaining the prompt (if the room items have been generated). This allows users to adjust their prompt later for an already generated room.
5. Prompt
- The prompt that will be sent to ChatGPT.
- Here is an example prompt for a reception area:
- "This is the room where we meet our customers. Make sure there is a set of comfortable armchairs, a sofa, and a coffee table"
6. Use ChatGPT
- This enables the extension to call ChatGPT, otherwise it will use a default assistant prompt which will be the same every time.
7. Use Deepsearch (ENTERPRISE USERS ONLY)
- This enables the extension to use Deepsearch
8. Generate
- With a room selected and a prompt, this will send all the related information to ChatGPT. A progress bar will show up indicating if the response is still going.
9. ChatGPT Reponse / Log
- Once you have hit *Generate* this collapsable frame will contain the output recieved from ChatGPT. Here you can view the JSON data or if any issues arise with ChatGPT.
## How it works
### Getting information about the 3D Scene
Everything starts with the USD scene in Omniverse. Users can easily circle an area using the Pencil tool in Omniverse or create a cube and scale it in the scene, type in the kind of room/environment they want to generate - for example, a warehouse, or a reception room - and with one click that area is created.
### Creating the Prompt for ChatGPT
The ChatGPT prompt is composed of four pieces; system input, user input example, assistant output example, and user prompt.
Let’s start with the aspects of the prompt that tailor to the user’s scenario. This includes text that the user inputs plus data from the scene.
For example, if the user wants to create a reception room, they specify something like “This is the room where we meet our customers. Make sure there is a set of comfortable armchairs, a sofa and a coffee table”. Or, if they want to add a certain number of items they could add “make sure to include a minimum of 10 items”.
This text is combined with scene information like the size and name of the area where we will place items as the User Prompt.
### Passing the results from ChatGPT
The items from the ChatGPT JSON response are then parsed by the extension and passed to the Omnivere DeepSearch API. DeepSearch allows users to search 3D models stored within an Omniverse Nucleus server using natural language queries.
This means that even if we don’t know the exact file name of a model of a sofa, for example, we can retrieve it just by searching for “Comfortable Sofa” which is exactly what we got from ChatGPT.
DeepSearch understands natural language and by asking it for a “Comfortable Sofa” we get a list of items that our helpful AI librarian has decided are best suited from the selection of assets we have in our current asset library. It is surprisingly good at this and so we often can use the first item it returns, but of course we build in choice in case the user wants to select something from the list.
### When not using Deepsearch
For those who are not Enterprise users or users that want to use greyboxing, by default as long as `use Deepsearch` is turned off the extension will generate cube of various shapes and sizes to best suit the response from ChatGPT. | 4,975 | Markdown | 73.268656 | 404 | 0.776482 |
NVIDIA-Omniverse/AnariUsdDevice/UsdParameterizedObject.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include <map>
#include <string>
#include <cstring>
#include <cassert>
#include <algorithm>
#include <vector>
#include "UsdAnari.h"
#include "UsdSharedObjects.h"
#include "UsdMultiTypeParameter.h"
#include "helium/utility/IntrusivePtr.h"
#include "anari/frontend/type_utility.h"
class UsdDevice;
class UsdBridge;
// When deriving from UsdParameterizedObject<T>, define a a struct T::Data and
// a static void T::registerParams() that registers any member of T::Data using REGISTER_PARAMETER_MACRO()
template<typename T, typename D>
class UsdParameterizedObject
{
public:
struct UsdAnariDataTypeStore
{
ANARIDataType type0 = ANARI_UNKNOWN;
ANARIDataType type1 = ANARI_UNKNOWN;
ANARIDataType type2 = ANARI_UNKNOWN;
ANARIDataType singleType() const { return type0; }
bool isMultiType() const { return type1 != ANARI_UNKNOWN; }
bool typeMatches(ANARIDataType inType) const
{
return inType == type0 ||
(isMultiType() && (inType == type1 || inType == type2));
}
};
struct ParamTypeInfo
{
size_t dataOffset = 0; // offset of data, within paramDataSet D
size_t typeOffset = 0; // offset of type, from data
size_t size = 0; // Total size of data+type
UsdAnariDataTypeStore types;
};
using ParameterizedClassType = UsdParameterizedObject<T, D>;
using ParamContainer = std::map<std::string, ParamTypeInfo>;
void* getParam(const char* name, ANARIDataType& returnType)
{
// Check if name registered
typename ParamContainer::iterator it = registeredParams->find(name);
if (it != registeredParams->end())
{
const ParamTypeInfo& typeInfo = it->second;
void* destAddress = nullptr;
getParamTypeAndAddress(paramDataSets[paramWriteIdx], typeInfo,
returnType, destAddress);
return destAddress;
}
return nullptr;
}
protected:
helium::RefCounted** ptrToRefCountedPtr(void* address) { return reinterpret_cast<helium::RefCounted**>(address); }
ANARIDataType* toAnariDataTypePtr(void* address) { return reinterpret_cast<ANARIDataType*>(address); }
bool isRefCounted(ANARIDataType type) const { return anari::isObject(type) || type == ANARI_STRING; }
void safeRefInc(void* paramPtr) // Pointer to the parameter address which holds a helium::RefCounted*
{
helium::RefCounted** refCountedPP = ptrToRefCountedPtr(paramPtr);
if (*refCountedPP)
(*refCountedPP)->refInc(helium::RefType::INTERNAL);
}
void safeRefDec(void* paramPtr, ANARIDataType paramType) // Pointer to the parameter address which holds a helium::RefCounted*
{
helium::RefCounted** refCountedPP = ptrToRefCountedPtr(paramPtr);
if (*refCountedPP)
{
helium::RefCounted*& refCountedP = *refCountedPP;
#ifdef CHECK_MEMLEAKS
logDeallocationThroughDevice(allocDevice, refCountedP, paramType);
#endif
assert(refCountedP->useCount(helium::RefType::INTERNAL) > 0);
refCountedP->refDec(helium::RefType::INTERNAL);
refCountedP = nullptr; // Explicitly clear the pointer (see destructor)
}
}
void* paramAddress(D& paramData, const ParamTypeInfo& typeInfo)
{
return reinterpret_cast<char*>(¶mData) + typeInfo.dataOffset;
}
ANARIDataType paramType(void* paramAddress, const ParamTypeInfo& typeInfo)
{
if(typeInfo.types.isMultiType())
return *toAnariDataTypePtr(static_cast<char*>(paramAddress) + typeInfo.typeOffset);
else
return typeInfo.types.singleType();
}
void setMultiParamType(void* paramAddress, const ParamTypeInfo& typeInfo, ANARIDataType newType)
{
if(typeInfo.types.isMultiType())
*toAnariDataTypePtr(static_cast<char*>(paramAddress) + typeInfo.typeOffset) = newType;
}
void getParamTypeAndAddress(D& paramData, const ParamTypeInfo& typeInfo,
ANARIDataType& returnType, void*& returnAddress)
{
returnAddress = paramAddress(paramData, typeInfo);
returnType = paramType(returnAddress, typeInfo);
}
// Convenience function for usd-compatible parameters
void formatUsdName(UsdSharedString* nameStr)
{
char* name = const_cast<char*>(UsdSharedString::c_str(nameStr));
assert(strlen(name) > 0);
auto letter = [](unsigned c) { return ((c - 'A') < 26) || ((c - 'a') < 26); };
auto number = [](unsigned c) { return (c - '0') < 10; };
auto under = [](unsigned c) { return c == '_'; };
unsigned x = *name;
if (!letter(x) && !under(x)) { *name = '_'; }
x = *(++name);
while (x != '\0')
{
if(!letter(x) && !number(x) && !under(x))
*name = '_';
x = *(++name);
};
}
public:
UsdParameterizedObject()
{
static ParamContainer* reg = ParameterizedClassType::registerParams();
registeredParams = reg;
}
~UsdParameterizedObject()
{
// Manually decrease the references on all objects in the read and writeparam datasets
// (since the pointers are relinquished)
auto it = registeredParams->begin();
while (it != registeredParams->end())
{
const ParamTypeInfo& typeInfo = it->second;
ANARIDataType readParamType, writeParamType;
void* readParamAddress = nullptr;
void* writeParamAddress = nullptr;
getParamTypeAndAddress(paramDataSets[paramReadIdx], typeInfo,
readParamType, readParamAddress);
getParamTypeAndAddress(paramDataSets[paramWriteIdx], typeInfo,
writeParamType, writeParamAddress);
// Works even if two parameters point to the same object, as the object pointers are set to null
if(isRefCounted(readParamType))
safeRefDec(readParamAddress, readParamType);
if(isRefCounted(writeParamType))
safeRefDec(writeParamAddress, writeParamType);
++it;
}
}
const D& getReadParams() const { return paramDataSets[paramReadIdx]; }
D& getWriteParams() { return paramDataSets[paramWriteIdx]; }
protected:
void setParam(const char* name, ANARIDataType srcType, const void* rawSrc, UsdDevice* device)
{
#ifdef CHECK_MEMLEAKS
allocDevice = device;
#endif
if(srcType == ANARI_UNKNOWN)
{
reportStatusThroughDevice(UsdLogInfo(device, this, ANARI_OBJECT, nullptr), ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"Attempting to set param %s with type %s", name, AnariTypeToString(srcType));
return;
}
else if(anari::isArray(srcType))
{
// Flatten the source type in case of array
srcType = ANARI_ARRAY;
}
// Check if name registered
typename ParamContainer::iterator it = registeredParams->find(name);
if (it != registeredParams->end())
{
const ParamTypeInfo& typeInfo = it->second;
// Check if type matches
if (typeInfo.types.typeMatches(srcType))
{
ANARIDataType destType;
void* destAddress = nullptr;
getParamTypeAndAddress(paramDataSets[paramWriteIdx], typeInfo,
destType, destAddress);
const void* srcAddress = rawSrc; //temporary src
size_t numBytes = anari::sizeOf(srcType); // Size is determined purely by source data
bool contentUpdate = srcType != destType; // Always do a content update if types differ (in case of multitype params)
// Update data for all the different types
if (srcType == ANARI_BOOL)
{
bool* destBool_p = reinterpret_cast<bool*>(destAddress);
bool srcBool = *(reinterpret_cast<const uint32_t*>(srcAddress));
contentUpdate = contentUpdate || (*destBool_p != srcBool);
*destBool_p = srcBool;
}
else
{
UsdSharedString* sharedStr = nullptr;
if (srcType == ANARI_STRING)
{
// Wrap strings to make them refcounted,
// from that point they are considered normal RefCounteds.
UsdSharedString* destStr = reinterpret_cast<UsdSharedString*>(*ptrToRefCountedPtr(destAddress));
const char* srcCstr = reinterpret_cast<const char*>(srcAddress);
contentUpdate = contentUpdate || !destStr || !strEquals(destStr->c_str(), srcCstr); // Note that execution of strEquals => (srcType == destType)
if(contentUpdate)
{
sharedStr = new UsdSharedString(srcCstr); // Remember to refdec
numBytes = sizeof(void*);
srcAddress = &sharedStr;
#ifdef CHECK_MEMLEAKS
logAllocationThroughDevice(allocDevice, sharedStr, ANARI_STRING);
#endif
}
}
else
contentUpdate = contentUpdate || bool(std::memcmp(destAddress, srcAddress, numBytes));
if(contentUpdate)
{
if(isRefCounted(destType))
safeRefDec(destAddress, destType);
std::memcpy(destAddress, srcAddress, numBytes);
if(isRefCounted(srcType))
safeRefInc(destAddress);
}
// If a string object has been created, decrease its public refcount (1 at creation)
if (sharedStr)
{
assert(sharedStr->useCount() == 2); // Single public and internal reference
sharedStr->refDec();
}
}
// Update the type for multitype params (so far only data has been updated)
if(contentUpdate)
setMultiParamType(destAddress, typeInfo, srcType);
if(!strEquals(name, "usd::time")) // Allow for re-use of object as reference at different timestep, without triggering a full re-commit of the referenced object
{
#ifdef TIME_BASED_CACHING
paramChanged = true; //For time-varying parameters, comparisons between content of potentially different timesteps is meaningless
#else
paramChanged = paramChanged || contentUpdate;
#endif
}
}
else
reportStatusThroughDevice(UsdLogInfo(device, this, ANARI_OBJECT, nullptr), ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"Param %s is not of an accepted type. For example, use %s instead.", name, AnariTypeToString(typeInfo.types.type0));
}
}
void resetParam(const ParamTypeInfo& typeInfo)
{
size_t paramSize = typeInfo.size;
// Copy to existing write param location
ANARIDataType destType;
void* destAddress = nullptr;
getParamTypeAndAddress(paramDataSets[paramWriteIdx], typeInfo,
destType, destAddress);
// Create temporary default-constructed parameter set and find source param address ((multi-)type is of no concern)
D defaultParamData;
void* srcAddress = paramAddress(defaultParamData, typeInfo);
// Make sure to dec existing ptr, as it will be relinquished
if(isRefCounted(destType))
safeRefDec(destAddress, destType);
// Just replace contents of the whole parameter structure, single or multiparam
std::memcpy(destAddress, srcAddress, paramSize);
}
void resetParam(const char* name)
{
typename ParamContainer::iterator it = registeredParams->find(name);
if (it != registeredParams->end())
{
const ParamTypeInfo& typeInfo = it->second;
resetParam(typeInfo);
if(!strEquals(name, "usd::time"))
{
paramChanged = true;
}
}
}
void resetParams()
{
auto it = registeredParams->begin();
while (it != registeredParams->end())
{
resetParam(it->second);
++it;
}
paramChanged = true;
}
void transferWriteToReadParams()
{
// Make sure object references are removed for
// the overwritten readparams, and increased for the source writeparams
auto it = registeredParams->begin();
while (it != registeredParams->end())
{
const ParamTypeInfo& typeInfo = it->second;
ANARIDataType srcType, destType;
void* srcAddress = nullptr;
void* destAddress = nullptr;
getParamTypeAndAddress(paramDataSets[paramWriteIdx], typeInfo,
srcType, srcAddress);
getParamTypeAndAddress(paramDataSets[paramReadIdx], typeInfo,
destType, destAddress);
// SrcAddress and destAddress are not the same, but they may specifically contain the same object pointers.
// Branch out on that situation (may also be disabled, which results in a superfluous inc/dec)
if(std::memcmp(destAddress, srcAddress, typeInfo.size))
{
// First inc, then dec (in case branch is taken out and the pointed to object is the same)
if (isRefCounted(srcType))
safeRefInc(srcAddress);
if (isRefCounted(destType))
safeRefDec(destAddress, destType);
// Perform assignment immediately; there may be multiple parameters with the same object target,
// which will be branched out at the compare the second time around
std::memcpy(destAddress, srcAddress, typeInfo.size);
}
++it;
}
}
static ParamContainer* registerParams();
ParamContainer* registeredParams;
typedef T DerivedClassType;
typedef D DataType;
D paramDataSets[2];
constexpr static unsigned int paramReadIdx = 0;
constexpr static unsigned int paramWriteIdx = 1;
bool paramChanged = false;
#ifdef CHECK_MEMLEAKS
UsdDevice* allocDevice = nullptr;
#endif
};
#define DEFINE_PARAMETER_MAP(DefClass, Params) template<> UsdParameterizedObject<DefClass,DefClass::DataType>::ParamContainer* UsdParameterizedObject<DefClass,DefClass::DataType>::registerParams() { static ParamContainer registeredParams; Params return ®isteredParams; }
#define REGISTER_PARAMETER_MACRO(ParamName, ParamType, ParamData) \
registeredParams.emplace( std::make_pair<std::string, ParamTypeInfo>( \
std::string(ParamName), \
{offsetof(DataType, ParamData), 0, sizeof(DataType::ParamData), {ParamType, ANARI_UNKNOWN, ANARI_UNKNOWN}} \
)); \
static_assert(ParamType == anari::ANARITypeFor<decltype(DataType::ParamData)>::value, "ANARI type " #ParamType " of member '" #ParamData "' does not correspond to member type");
#define REGISTER_PARAMETER_MULTITYPE_MACRO(ParamName, ParamType0, ParamType1, ParamType2, ParamData) \
{ \
static_assert(ParamType0 == decltype(DataType::ParamData)::AnariType0, "MultiTypeParams registration: ParamType0 " #ParamType0 " of member '" #ParamData "' doesn't match AnariType0"); \
static_assert(ParamType1 == decltype(DataType::ParamData)::AnariType1, "MultiTypeParams registration: ParamType1 " #ParamType1 " of member '" #ParamData "' doesn't match AnariType1"); \
static_assert(ParamType2 == decltype(DataType::ParamData)::AnariType2, "MultiTypeParams registration: ParamType2 " #ParamType2 " of member '" #ParamData "' doesn't match AnariType2"); \
size_t dataOffset = offsetof(DataType, ParamData); \
size_t typeOffset = offsetof(DataType, ParamData.type); \
registeredParams.emplace( std::make_pair<std::string, ParamTypeInfo>( \
std::string(ParamName), \
{dataOffset, typeOffset - dataOffset, sizeof(DataType::ParamData), {ParamType0, ParamType1, ParamType2}} \
)); \
}
// Static assert explainer: gets the element type of the array via the decltype of *std::begin(), which in turn accepts an array
#define REGISTER_PARAMETER_ARRAY_MACRO(ParamName, ParamNameSuffix, ParamType, ParamData, NumEntries) \
{ \
using element_type_t = std::remove_reference_t<decltype(*std::begin(std::declval<decltype(DataType::ParamData)&>()))>; \
static_assert(ParamType == anari::ANARITypeFor<element_type_t>::value, "ANARI type " #ParamType " of member '" #ParamData "' does not correspond to member type"); \
static_assert(sizeof(decltype(DataType::ParamData)) == sizeof(element_type_t)*NumEntries, "Number of elements of member '" #ParamData "' does not correspond with member declaration."); \
size_t offset0 = offsetof(DataType, ParamData[0]); \
size_t offset1 = offsetof(DataType, ParamData[1]); \
size_t paramSize = offset1-offset0; \
for(int i = 0; i < NumEntries; ++i) \
{ \
registeredParams.emplace( std::make_pair<std::string, ParamTypeInfo>( \
ParamName + std::to_string(i) + ParamNameSuffix, \
{offset0+paramSize*i, 0, paramSize, {ParamType, ANARI_UNKNOWN, ANARI_UNKNOWN}} \
)); \
} \
}
| 16,145 | C | 35.947368 | 273 | 0.679282 |
NVIDIA-Omniverse/AnariUsdDevice/UsdRenderer.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBaseObject.h"
#include "UsdParameterizedObject.h"
struct UsdRendererData
{
};
class UsdRenderer : public UsdParameterizedBaseObject<UsdRenderer, UsdRendererData>
{
public:
UsdRenderer();
~UsdRenderer();
void remove(UsdDevice* device) override {}
int getProperty(const char * name, ANARIDataType type, void * mem, uint64_t size, UsdDevice* device) override;
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override {}
UsdBridge* usdBridge;
};
| 681 | C | 20.999999 | 114 | 0.737151 |
NVIDIA-Omniverse/AnariUsdDevice/UsdGeometry.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
#include <memory>
#include <limits>
class UsdDataArray;
struct UsdBridgeMeshData;
static constexpr int MAX_ATTRIBS = 16;
enum class UsdGeometryComponents
{
POSITION = 0,
NORMAL,
COLOR,
INDEX,
SCALE,
ORIENTATION,
ID,
ATTRIBUTE0,
ATTRIBUTE1,
ATTRIBUTE2,
ATTRIBUTE3
};
struct UsdGeometryData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
double timeStep = 0.0;
int timeVarying = 0xFFFFFFFF; // TimeVarying bits
const UsdDataArray* vertexPositions = nullptr;
const UsdDataArray* vertexNormals = nullptr;
const UsdDataArray* vertexColors = nullptr;
const UsdDataArray* vertexAttributes[MAX_ATTRIBS] = { nullptr };
const UsdDataArray* primitiveNormals = nullptr;
const UsdDataArray* primitiveColors = nullptr;
const UsdDataArray* primitiveAttributes[MAX_ATTRIBS] = { nullptr };
const UsdDataArray* primitiveIds = nullptr;
const UsdSharedString* attributeNames[MAX_ATTRIBS] = { nullptr };
const UsdDataArray* indices = nullptr;
// Spheres
const UsdDataArray* vertexRadii = nullptr;
float radiusConstant = 1.0f;
bool UseUsdGeomPoints =
#ifdef USE_USD_GEOM_POINTS
true;
#else
false;
#endif
// Cylinders
const UsdDataArray* primitiveRadii = nullptr;
// Curves
// Glyphs
const UsdDataArray* vertexScales = nullptr;
const UsdDataArray* primitiveScales = nullptr;
const UsdDataArray* vertexOrientations = nullptr;
const UsdDataArray* primitiveOrientations = nullptr;
UsdFloat3 scaleConstant = {1.0f, 1.0f, 1.0f};
UsdQuaternion orientationConstant;
UsdSharedString* shapeType = nullptr;
UsdGeometry* shapeGeometry = nullptr;
UsdFloatMat4 shapeTransform;
double shapeGeometryRefTimeStep = std::numeric_limits<float>::quiet_NaN();
};
struct UsdGeometryTempArrays;
class UsdGeometry : public UsdBridgedBaseObject<UsdGeometry, UsdGeometryData, UsdGeometryHandle, UsdGeometryComponents>
{
public:
enum GeomType
{
GEOM_UNKNOWN = 0,
GEOM_TRIANGLE,
GEOM_QUAD,
GEOM_SPHERE,
GEOM_CYLINDER,
GEOM_CONE,
GEOM_CURVE,
GEOM_GLYPH
};
typedef std::vector<UsdBridgeAttribute> AttributeArray;
typedef std::vector<std::vector<char>> AttributeDataArraysType;
UsdGeometry(const char* name, const char* type, UsdDevice* device);
~UsdGeometry();
void remove(UsdDevice* device) override;
void filterSetParam(const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device) override;
bool isInstanced() const
{
return geomType == GEOM_SPHERE
|| geomType == GEOM_CONE
|| geomType == GEOM_CYLINDER
|| geomType == GEOM_GLYPH;
}
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(UsdGeometryComponents::POSITION, "position"),
ComponentPair(UsdGeometryComponents::NORMAL, "normal"),
ComponentPair(UsdGeometryComponents::COLOR, "color"),
ComponentPair(UsdGeometryComponents::INDEX, "index"),
ComponentPair(UsdGeometryComponents::SCALE, "scale"),
ComponentPair(UsdGeometryComponents::SCALE, "radius"),
ComponentPair(UsdGeometryComponents::ORIENTATION, "orientation"),
ComponentPair(UsdGeometryComponents::ID, "id"),
ComponentPair(UsdGeometryComponents::ATTRIBUTE0, "attribute0"),
ComponentPair(UsdGeometryComponents::ATTRIBUTE1, "attribute1"),
ComponentPair(UsdGeometryComponents::ATTRIBUTE2, "attribute2"),
ComponentPair(UsdGeometryComponents::ATTRIBUTE3, "attribute3")};
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override;
void initializeGeomData(UsdBridgeMeshData& geomData);
void initializeGeomData(UsdBridgeInstancerData& geomData);
void initializeGeomData(UsdBridgeCurveData& geomData);
void initializeGeomRefData(UsdBridgeInstancerRefData& geomRefData);
bool checkArrayConstraints(const UsdDataArray* vertexArray, const UsdDataArray* primArray,
const char* paramName, UsdDevice* device, const char* debugName, int attribIndex = -1);
bool checkGeomParams(UsdDevice* device);
void updateGeomData(UsdDevice* device, UsdBridge* usdBridge, UsdBridgeMeshData& meshData, bool isNew);
void updateGeomData(UsdDevice* device, UsdBridge* usdBridge, UsdBridgeInstancerData& instancerData, bool isNew);
void updateGeomData(UsdDevice* device, UsdBridge* usdBridge, UsdBridgeCurveData& curveData, bool isNew);
template<typename UsdGeomType>
bool commitTemplate(UsdDevice* device);
void commitPrototypes(UsdBridge* usdBridge);
template<typename GeomDataType>
void setAttributeTimeVarying(typename GeomDataType::DataMemberId& timeVarying);
void syncAttributeArrays();
template<typename GeomDataType>
void copyAttributeArraysToData(GeomDataType& geomData);
void assignTempDataToAttributes(bool perPrimInterpolation);
GeomType geomType = GEOM_UNKNOWN;
bool protoShapeChanged = false; // Do not automatically commit shapes (the object may have been recreated onto an already existing USD prim)
std::unique_ptr<UsdGeometryTempArrays> tempArrays;
AttributeArray attributeArray;
}; | 5,365 | C | 29.83908 | 144 | 0.741473 |
NVIDIA-Omniverse/AnariUsdDevice/UsdMaterial.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
#include "UsdBridgeNumerics.h"
#include "UsdDeviceUtils.h"
#include <limits>
class UsdSampler;
template<typename ValueType>
using UsdMaterialMultiTypeParameter = UsdMultiTypeParameter<ValueType, UsdSampler*, UsdSharedString*>;
enum class UsdMaterialDataComponents
{
COLOR = 0,
OPACITY,
EMISSIVE,
EMISSIVEFACTOR,
ROUGHNESS,
METALLIC,
IOR
};
struct UsdMaterialData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
double timeStep = std::numeric_limits<float>::quiet_NaN();
int timeVarying = 0; // Bitmask indicating which attributes are time-varying.
// Standard parameters
UsdMaterialMultiTypeParameter<UsdFloat3> color = {{ 1.0f, 1.0f, 1.0f }, ANARI_FLOAT32_VEC3};
UsdMaterialMultiTypeParameter<float> opacity = {1.0f, ANARI_FLOAT32};
UsdSharedString* alphaMode = nullptr; // Timevarying state linked to opacity
float alphaCutoff = 0.5f; // Timevarying state linked to opacity
// Possible PBR parameters
UsdMaterialMultiTypeParameter<UsdFloat3> emissiveColor = {{ 1.0f, 1.0f, 1.0f }, ANARI_FLOAT32_VEC3};
UsdMaterialMultiTypeParameter<float> emissiveIntensity = {0.0f, ANARI_FLOAT32};
UsdMaterialMultiTypeParameter<float> roughness = {0.5f, ANARI_FLOAT32};
UsdMaterialMultiTypeParameter<float> metallic = {0.0f, ANARI_FLOAT32};
UsdMaterialMultiTypeParameter<float> ior = {1.0f, ANARI_FLOAT32};
double colorSamplerTimeStep = std::numeric_limits<float>::quiet_NaN();
double opacitySamplerTimeStep = std::numeric_limits<float>::quiet_NaN();
double emissiveSamplerTimeStep = std::numeric_limits<float>::quiet_NaN();
double emissiveIntensitySamplerTimeStep = std::numeric_limits<float>::quiet_NaN();
double roughnessSamplerTimeStep = std::numeric_limits<float>::quiet_NaN();
double metallicSamplerTimeStep = std::numeric_limits<float>::quiet_NaN();
double iorSamplerTimeStep = std::numeric_limits<float>::quiet_NaN();
};
class UsdMaterial : public UsdBridgedBaseObject<UsdMaterial, UsdMaterialData, UsdMaterialHandle, UsdMaterialDataComponents>
{
public:
using MaterialDMI = UsdBridgeMaterialData::DataMemberId;
UsdMaterial(const char* name, const char* type, UsdDevice* device);
~UsdMaterial();
void remove(UsdDevice* device) override;
bool isPerInstance() const { return perInstance; }
void updateBoundParameters(bool boundToInstance, UsdDevice* device);
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(UsdMaterialDataComponents::COLOR, "color"),
ComponentPair(UsdMaterialDataComponents::COLOR, "baseColor"),
ComponentPair(UsdMaterialDataComponents::OPACITY, "opacity"),
ComponentPair(UsdMaterialDataComponents::EMISSIVE, "emissive"),
ComponentPair(UsdMaterialDataComponents::EMISSIVEFACTOR, "emissiveIntensity"),
ComponentPair(UsdMaterialDataComponents::ROUGHNESS, "roughness"),
ComponentPair(UsdMaterialDataComponents::METALLIC, "metallic"),
ComponentPair(UsdMaterialDataComponents::IOR, "ior")};
protected:
using MaterialInputAttribNamePair = std::pair<MaterialDMI, const char*>;
template<typename ValueType>
bool getMaterialInputSourceName(const UsdMaterialMultiTypeParameter<ValueType>& param,
MaterialDMI dataMemberId, UsdDevice* device, const UsdLogInfo& logInfo);
template<typename ValueType>
bool getSamplerRefData(const UsdMaterialMultiTypeParameter<ValueType>& param, double refTimeStep,
MaterialDMI dataMemberId, UsdDevice* device, const UsdLogInfo& logInfo);
template<typename ValueType>
void assignParameterToMaterialInput(
const UsdMaterialMultiTypeParameter<ValueType>& param,
UsdBridgeMaterialData::MaterialInput<ValueType>& matInput,
const UsdLogInfo& logInfo);
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override;
void setMaterialTimeVarying(UsdBridgeMaterialData::DataMemberId& timeVarying);
bool isPbr = false;
bool perInstance = false; // Whether material is attached to a point instancer
bool instanceAttributeAttached = false; // Whether a value to any parameter has been set which in USD is different between per-instance and regular geometries
OptionalList<MaterialInputAttribNamePair> materialInputAttributes;
OptionalList<UsdSamplerHandle> samplerHandles;
OptionalList<UsdSamplerRefData> samplerRefDatas;
}; | 4,548 | C | 39.981982 | 162 | 0.769789 |
NVIDIA-Omniverse/AnariUsdDevice/UsdMaterial.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdMaterial.h"
#include "UsdAnari.h"
#include "UsdDevice.h"
#include "UsdSampler.h"
#include "UsdDataArray.h"
#define SamplerType ANARI_SAMPLER
using SamplerUsdType = AnariToUsdBridgedObject<SamplerType>::Type;
#define REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO(ParamName, ParamType0, ParamData) \
REGISTER_PARAMETER_MULTITYPE_MACRO(ParamName, ParamType0, SamplerType, ANARI_STRING, ParamData)
DEFINE_PARAMETER_MAP(UsdMaterial,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::time", ANARI_FLOAT64, timeStep)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("usd::time.sampler.color", ANARI_FLOAT64, colorSamplerTimeStep)
REGISTER_PARAMETER_MACRO("usd::time.sampler.baseColor", ANARI_FLOAT64, colorSamplerTimeStep)
REGISTER_PARAMETER_MACRO("usd::time.sampler.opacity", ANARI_FLOAT64, opacitySamplerTimeStep)
REGISTER_PARAMETER_MACRO("usd::time.sampler.emissive", ANARI_FLOAT64, emissiveSamplerTimeStep)
REGISTER_PARAMETER_MACRO("usd::time.sampler.emissiveIntensity", ANARI_FLOAT64, emissiveIntensitySamplerTimeStep)
REGISTER_PARAMETER_MACRO("usd::time.sampler.roughness", ANARI_FLOAT64, roughnessSamplerTimeStep)
REGISTER_PARAMETER_MACRO("usd::time.sampler.metallic", ANARI_FLOAT64, metallicSamplerTimeStep)
REGISTER_PARAMETER_MACRO("usd::time.sampler.ior", ANARI_FLOAT64, iorSamplerTimeStep)
REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO("color", ANARI_FLOAT32_VEC3, color)
REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO("baseColor", ANARI_FLOAT32_VEC3, color)
REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO("opacity", ANARI_FLOAT32, opacity)
REGISTER_PARAMETER_MACRO("alphaMode", ANARI_STRING, alphaMode)
REGISTER_PARAMETER_MACRO("alphaCutoff", ANARI_FLOAT32, alphaCutoff)
REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO("emissive", ANARI_FLOAT32_VEC3, emissiveColor)
REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO("emissiveIntensity", ANARI_FLOAT32, emissiveIntensity)
REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO("roughness", ANARI_FLOAT32, roughness)
REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO("metallic", ANARI_FLOAT32, metallic)
REGISTER_PARAMETER_MATERIAL_MULTITYPE_MACRO("ior", ANARI_FLOAT32, ior)
)
constexpr UsdMaterial::ComponentPair UsdMaterial::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
using DMI = UsdMaterial::MaterialDMI;
UsdMaterial::UsdMaterial(const char* name, const char* type, UsdDevice* device)
: BridgedBaseObjectType(ANARI_MATERIAL, name, device)
{
if (strEquals(type, "matte"))
{
isPbr = false;
}
else if (strEquals(type, "physicallyBased"))
{
isPbr = true;
}
else
{
device->reportStatus(this, ANARI_MATERIAL, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdMaterial '%s' intialization error: unknown material type", getName());
}
}
UsdMaterial::~UsdMaterial()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
if(cachedBridge)
cachedBridge->DeleteMaterial(usdHandle);
#endif
}
void UsdMaterial::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteMaterial);
}
template<typename ValueType>
bool UsdMaterial::getMaterialInputSourceName(const UsdMaterialMultiTypeParameter<ValueType>& param, MaterialDMI dataMemberId, UsdDevice* device, const UsdLogInfo& logInfo)
{
bool hasPositionAttrib = false;
UsdSharedString* anariAttribStr = nullptr;
param.Get(anariAttribStr);
const char* anariAttrib = UsdSharedString::c_str(anariAttribStr);
if(anariAttrib)
{
hasPositionAttrib = strEquals(anariAttrib, "objectPosition");
if( hasPositionAttrib && instanceAttributeAttached)
{
// In case of a per-instance specific attribute name, there can be only one change of the attribute name.
// Otherwise there is a risk of the material attribute being used for two differently named attributes.
reportStatusThroughDevice(logInfo, ANARI_SEVERITY_WARNING, ANARI_STATUS_INVALID_ARGUMENT,
"UsdMaterial '%s' binds one of its parameters to %s, but is transitively bound to both an instanced geometry (cones, spheres, cylinders) and regular geometry. \
This is incompatible with USD, which demands a differently bound name for those categories. \
Please create two different samplers and bind each to only one of both categories of geometry. \
The parameter value will be updated, but may therefore invalidate previous bindings to the objectPosition attribute.", logInfo.sourceName, "'objectPosition'");
}
const char* usdAttribName = AnariAttributeToUsdName(anariAttrib, perInstance, logInfo);
materialInputAttributes.push_back(UsdBridge::MaterialInputAttribName(dataMemberId, usdAttribName));
}
return hasPositionAttrib;
}
template<typename ValueType>
bool UsdMaterial::getSamplerRefData(const UsdMaterialMultiTypeParameter<ValueType>& param, double refTimeStep, MaterialDMI dataMemberId, UsdDevice* device, const UsdLogInfo& logInfo)
{
UsdSampler* sampler = nullptr;
param.Get(sampler);
if(sampler)
{
const UsdSamplerData& samplerParamData = sampler->getReadParams();
double worldTimeStep = device->getReadParams().timeStep;
double samplerObjTimeStep = samplerParamData.timeStep;
double samplerRefTime = selectRefTime(refTimeStep, samplerObjTimeStep, worldTimeStep);
// Reading child (sampler) data in the material has the consequence that the sampler's parameters as they were last committed are in effect "part of" the material parameter set, at this point of commit.
// So in case a sampler at a particular timestep is referenced from a material at two different world timesteps
// - ie. for this world timestep, a particular timestep of an image already committed and subsequently referenced at some other previous world timestep is reused -
// the user needs to make sure that not only the timestep is set correctly on the sampler for the commit (which is by itself lightweight, as it does not trigger a full commit),
// but also that the parameters read here have been re-set on the sampler to the values belonging to the referenced timestep, as if there is no USD representation of a sampler object.
// Setting those parameters will in turn trigger a full commit of the sampler object, which is in theory inefficient.
// However, in case of a sampler this is not a problem in practice; data transfer is only a concern when the filename is *not* set, at which point a relative file corresponding
// to the sampler timestep will be automatically chosen and set for the material, without the sampler object requiring any updates.
// In case a filename *is* set, only the filename is used and no data transfer/file io operations are performed.
//const char* imageUrl = UsdSharedString::c_str(samplerParamData.imageUrl); // not required anymore since all materials are a graph
int imageNumComponents = 4;
if(samplerParamData.imageData)
{
imageNumComponents = static_cast<int>(anari::componentsOf(samplerParamData.imageData->getType()));
}
UsdSamplerRefData samplerRefData = {imageNumComponents, samplerRefTime, dataMemberId};
samplerHandles.push_back(sampler->getUsdHandle());
samplerRefDatas.push_back(samplerRefData);
}
return false;
}
template<typename ValueType>
void UsdMaterial::assignParameterToMaterialInput(const UsdMaterialMultiTypeParameter<ValueType>& param,
UsdBridgeMaterialData::MaterialInput<ValueType>& matInput, const UsdLogInfo& logInfo)
{
param.Get(matInput.Value);
UsdSharedString* anariAttribStr = nullptr;
matInput.SrcAttrib = param.Get(anariAttribStr) ?
AnariAttributeToUsdName(anariAttribStr->c_str(), perInstance, logInfo) :
nullptr;
UsdSampler* sampler = nullptr;
matInput.Sampler = param.Get(sampler);
}
void UsdMaterial::updateBoundParameters(bool boundToInstance, UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdMaterialData& paramData = getReadParams();
if(perInstance != boundToInstance)
{
UsdLogInfo logInfo = {device, this, ANARI_MATERIAL, getName()};
double worldTimeStep = device->getReadParams().timeStep;
double dataTimeStep = selectObjTime(paramData.timeStep, worldTimeStep);
// Fix up any parameters that have a geometry-type-dependent name set as source attribute
materialInputAttributes.clear();
bool hasPositionAttrib =
getMaterialInputSourceName(paramData.color, DMI::DIFFUSE, device, logInfo) ||
getMaterialInputSourceName(paramData.opacity, DMI::OPACITY, device, logInfo) ||
getMaterialInputSourceName(paramData.emissiveColor, DMI::EMISSIVECOLOR, device, logInfo) ||
getMaterialInputSourceName(paramData.emissiveIntensity, DMI::EMISSIVEINTENSITY, device, logInfo) ||
getMaterialInputSourceName(paramData.roughness, DMI::ROUGHNESS, device, logInfo) ||
getMaterialInputSourceName(paramData.metallic, DMI::METALLIC, device, logInfo) ||
getMaterialInputSourceName(paramData.ior, DMI::IOR, device, logInfo);
DMI timeVarying;
setMaterialTimeVarying(timeVarying);
// Fixup attribute name and type depending on the newly bound geometry
if(materialInputAttributes.size())
usdBridge->ChangeMaterialInputAttributes(usdHandle, materialInputAttributes.data(), materialInputAttributes.size(), dataTimeStep, timeVarying);
if(hasPositionAttrib)
instanceAttributeAttached = true; // As soon as any parameter is set to a position attribute, the geometry type for this material is 'locked-in'
perInstance = boundToInstance;
}
if(paramData.color.type == SamplerType)
{
UsdSampler* colorSampler = nullptr;
if (paramData.color.Get(colorSampler))
{
colorSampler->updateBoundParameters(boundToInstance, device);
}
}
}
bool UsdMaterial::deferCommit(UsdDevice* device)
{
//const UsdMaterialData& paramData = getReadParams();
//if(UsdObjectNotInitialized<SamplerUsdType>(paramData.color.type == SamplerType))
//{
// return true;
//}
return false;
}
bool UsdMaterial::doCommitData(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
if(!device->getReadParams().outputMaterial)
return false;
bool isNew = false;
if (!usdHandle.value)
isNew = usdBridge->CreateMaterial(getName(), usdHandle);
if (paramChanged || isNew)
{
const UsdMaterialData& paramData = getReadParams();
double worldTimeStep = device->getReadParams().timeStep;
double dataTimeStep = selectObjTime(paramData.timeStep, worldTimeStep);
UsdBridgeMaterialData matData;
matData.IsPbr = isPbr;
matData.AlphaMode = AnariToUsdAlphaMode(UsdSharedString::c_str(paramData.alphaMode));
matData.AlphaCutoff = paramData.alphaCutoff;
UsdLogInfo logInfo = {device, this, ANARI_MATERIAL, getName()};
assignParameterToMaterialInput(paramData.color, matData.Diffuse, logInfo);
assignParameterToMaterialInput(paramData.opacity, matData.Opacity, logInfo);
assignParameterToMaterialInput(paramData.emissiveColor, matData.Emissive, logInfo);
assignParameterToMaterialInput(paramData.emissiveIntensity, matData.EmissiveIntensity, logInfo);
assignParameterToMaterialInput(paramData.roughness, matData.Roughness, logInfo);
assignParameterToMaterialInput(paramData.metallic, matData.Metallic, logInfo);
assignParameterToMaterialInput(paramData.ior, matData.Ior, logInfo);
setMaterialTimeVarying(matData.TimeVarying);
usdBridge->SetMaterialData(usdHandle, matData, dataTimeStep);
paramChanged = false;
return paramData.color.type == SamplerType; // Only commit refs when material actually contains a texture (filename param from diffusemap is required)
}
return false;
}
void UsdMaterial::doCommitRefs(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdMaterialData& paramData = getReadParams();
double worldTimeStep = device->getReadParams().timeStep;
samplerHandles.clear();
samplerRefDatas.clear();
UsdLogInfo logInfo = {device, this, ANARI_MATERIAL, getName()};
getSamplerRefData(paramData.color, paramData.colorSamplerTimeStep, DMI::DIFFUSE, device, logInfo);
getSamplerRefData(paramData.opacity, paramData.opacitySamplerTimeStep, DMI::OPACITY, device, logInfo);
getSamplerRefData(paramData.emissiveColor, paramData.emissiveSamplerTimeStep, DMI::EMISSIVECOLOR, device, logInfo);
getSamplerRefData(paramData.emissiveIntensity, paramData.emissiveIntensitySamplerTimeStep, DMI::EMISSIVEINTENSITY, device, logInfo);
getSamplerRefData(paramData.roughness, paramData.roughnessSamplerTimeStep, DMI::ROUGHNESS, device, logInfo);
getSamplerRefData(paramData.metallic, paramData.metallicSamplerTimeStep, DMI::METALLIC, device, logInfo);
getSamplerRefData(paramData.ior, paramData.iorSamplerTimeStep, DMI::IOR, device, logInfo);
if(samplerHandles.size())
usdBridge->SetSamplerRefs(usdHandle, samplerHandles.data(), samplerHandles.size(), worldTimeStep, samplerRefDatas.data());
else
usdBridge->DeleteSamplerRefs(usdHandle, worldTimeStep);
}
void UsdMaterial::setMaterialTimeVarying(UsdBridgeMaterialData::DataMemberId& timeVarying)
{
timeVarying = DMI::ALL
& (isTimeVarying(CType::COLOR) ? DMI::ALL : ~DMI::DIFFUSE)
& (isTimeVarying(CType::OPACITY) ? DMI::ALL : ~DMI::OPACITY)
& (isTimeVarying(CType::EMISSIVE) ? DMI::ALL : ~DMI::EMISSIVECOLOR)
& (isTimeVarying(CType::EMISSIVEFACTOR) ? DMI::ALL : ~DMI::EMISSIVEINTENSITY)
& (isTimeVarying(CType::ROUGHNESS) ? DMI::ALL : ~DMI::ROUGHNESS)
& (isTimeVarying(CType::METALLIC) ? DMI::ALL : ~DMI::METALLIC)
& (isTimeVarying(CType::IOR) ? DMI::ALL : ~DMI::IOR);
} | 13,810 | C++ | 45.190635 | 207 | 0.767343 |
NVIDIA-Omniverse/AnariUsdDevice/UsdWorld.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
class UsdDataArray;
enum class UsdWorldComponents
{
INSTANCES = 0,
SURFACES,
VOLUMES
};
struct UsdWorldData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
int timeVarying = 0xFFFFFFFF; // Bitmask indicating which attributes are time-varying.
UsdDataArray* instances = nullptr;
UsdDataArray* surfaces = nullptr;
UsdDataArray* volumes = nullptr;
};
class UsdWorld : public UsdBridgedBaseObject<UsdWorld, UsdWorldData, UsdWorldHandle, UsdWorldComponents>
{
public:
UsdWorld(const char* name, UsdDevice* device);
~UsdWorld();
void remove(UsdDevice* device) override;
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(UsdWorldComponents::INSTANCES, "instance"),
ComponentPair(UsdWorldComponents::SURFACES, "surface"),
ComponentPair(UsdWorldComponents::VOLUMES, "volume")};
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override;
std::vector<UsdInstanceHandle> instanceHandles; // for convenience
std::vector<UsdSurfaceHandle> surfaceHandles; // for convenience
std::vector<UsdVolumeHandle> volumeHandles; // for convenience
}; | 1,375 | C | 26.519999 | 104 | 0.749818 |
NVIDIA-Omniverse/AnariUsdDevice/UsdLight.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
struct UsdLightData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
};
class UsdLight : public UsdBridgedBaseObject<UsdLight, UsdLightData, UsdLightHandle>
{
public:
UsdLight(const char* name,
UsdDevice* device);
~UsdLight();
void remove(UsdDevice* device) override;
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override {}
};
| 612 | C | 20.892856 | 84 | 0.73366 |
NVIDIA-Omniverse/AnariUsdDevice/UsdFrame.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdFrame.h"
#include "UsdBridge/UsdBridge.h"
#include "UsdAnari.h"
#include "UsdDevice.h"
#include "anari/frontend/type_utility.h"
DEFINE_PARAMETER_MAP(UsdFrame,
REGISTER_PARAMETER_MACRO("world", ANARI_WORLD, world)
REGISTER_PARAMETER_MACRO("renderer", ANARI_RENDERER, renderer)
REGISTER_PARAMETER_MACRO("size", ANARI_UINT32_VEC2, size)
REGISTER_PARAMETER_MACRO("channel.color", ANARI_DATA_TYPE, color)
REGISTER_PARAMETER_MACRO("channel.depth", ANARI_DATA_TYPE, depth)
)
UsdFrame::UsdFrame(UsdBridge* bridge)
: UsdParameterizedBaseObject<UsdFrame, UsdFrameData>(ANARI_FRAME)
{
}
UsdFrame::~UsdFrame()
{
delete[] mappedColorMem;
delete[] mappedDepthMem;
}
bool UsdFrame::deferCommit(UsdDevice* device)
{
return false;
}
bool UsdFrame::doCommitData(UsdDevice* device)
{
return false;
}
const void* UsdFrame::mapBuffer(const char *channel,
uint32_t *width,
uint32_t *height,
ANARIDataType *pixelType)
{
const UsdFrameData& paramData = getReadParams();
*width = paramData.size.Data[0];
*height = paramData.size.Data[1];
*pixelType = ANARI_UNKNOWN;
if (strEquals(channel, "channel.color"))
{
mappedColorMem = ReserveBuffer(paramData.color);
*pixelType = paramData.color;
return mappedColorMem;
}
else if (strEquals(channel, "channel.depth"))
{
mappedDepthMem = ReserveBuffer(paramData.depth);
*pixelType = paramData.depth;
return mappedDepthMem;
}
*width = 0;
*height = 0;
return nullptr;
}
void UsdFrame::unmapBuffer(const char *channel)
{
if (strEquals(channel, "channel.color"))
{
delete[] mappedColorMem;
mappedColorMem = nullptr;
}
else if (strEquals(channel, "channel.depth"))
{
delete[] mappedDepthMem;
mappedDepthMem = nullptr;
}
}
char* UsdFrame::ReserveBuffer(ANARIDataType format)
{
const UsdFrameData& paramData = getReadParams();
size_t formatSize = anari::sizeOf(format);
size_t memSize = formatSize * paramData.size.Data[0] * paramData.size.Data[1];
return new char[memSize];
}
void UsdFrame::saveUsd(UsdDevice* device)
{
device->getUsdBridge()->SaveScene();
}
| 2,184 | C++ | 22 | 80 | 0.717491 |
NVIDIA-Omniverse/AnariUsdDevice/UsdSampler.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
enum class UsdSamplerComponents
{
DATA = 0,
WRAPS,
WRAPT,
WRAPR
};
struct UsdSamplerData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
double timeStep = 0.0;
int timeVarying = 0; // Bitmask indicating which attributes are time-varying.
const UsdDataArray* imageData = nullptr;
UsdSharedString* inAttribute = nullptr;
UsdSharedString* imageUrl = nullptr;
UsdSharedString* wrapS = nullptr;
UsdSharedString* wrapT = nullptr;
UsdSharedString* wrapR = nullptr;
};
class UsdSampler : public UsdBridgedBaseObject<UsdSampler, UsdSamplerData, UsdSamplerHandle, UsdSamplerComponents>
{
protected:
enum SamplerType
{
SAMPLER_UNKNOWN = 0,
SAMPLER_1D,
SAMPLER_2D,
SAMPLER_3D
};
public:
UsdSampler(const char* name, const char* type, UsdDevice* device);
~UsdSampler();
void remove(UsdDevice* device) override;
bool isPerInstance() const { return perInstance; }
void updateBoundParameters(bool boundToInstance, UsdDevice* device);
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(CType::DATA, "image"),
ComponentPair(CType::DATA, "imageUrl"),
ComponentPair(CType::WRAPS, "wrapMode"),
ComponentPair(CType::WRAPS, "wrapMode1"),
ComponentPair(CType::WRAPT, "wrapMode2"),
ComponentPair(CType::WRAPR, "wrapMode3")};
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override {}
void setSamplerTimeVarying(UsdBridgeSamplerData::DataMemberId& timeVarying);
SamplerType samplerType = SAMPLER_UNKNOWN;
bool perInstance = false; // Whether sampler is attached to a point instancer
bool instanceAttributeAttached = false; // Whether a value to inAttribute has been set which in USD is different between per-instance and regular geometries
}; | 2,050 | C | 27.486111 | 160 | 0.725854 |
NVIDIA-Omniverse/AnariUsdDevice/UsdInstance.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
class UsdGroup;
enum class UsdInstanceComponents
{
GROUP = 0,
TRANSFORM
};
struct UsdInstanceData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
int timeVarying = 0xFFFFFFFF; // Bitmask indicating which attributes are time-varying.
UsdGroup* group = nullptr;
UsdFloatMat4 transform;
};
class UsdInstance : public UsdBridgedBaseObject<UsdInstance, UsdInstanceData, UsdInstanceHandle, UsdInstanceComponents>
{
public:
UsdInstance(const char* name,
UsdDevice* device);
~UsdInstance();
void remove(UsdDevice* device) override;
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(UsdInstanceComponents::GROUP, "group"),
ComponentPair(UsdInstanceComponents::TRANSFORM, "transform")};
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override;
}; | 1,070 | C | 23.906976 | 119 | 0.750467 |
NVIDIA-Omniverse/AnariUsdDevice/UsdDataArray.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBaseObject.h"
#include "UsdParameterizedObject.h"
#include "anari/frontend/anari_enums.h"
class UsdDevice;
struct UsdDataLayout
{
bool isDense() const { return byteStride1 == typeSize && byteStride2 == numItems1*byteStride1 && byteStride3 == numItems2*byteStride2; }
bool isOneDimensional() const { return numItems2 == 1 && numItems3 == 1; }
void copyDims(uint64_t dims[3]) const { std::memcpy(dims, &numItems1, sizeof(uint64_t)*3); }
void copyStride(int64_t stride[3]) const { std::memcpy(stride, &byteStride1, sizeof(int64_t)*3); }
uint64_t typeSize = 0;
uint64_t numItems1 = 0;
uint64_t numItems2 = 0;
uint64_t numItems3 = 0;
int64_t byteStride1 = 0;
int64_t byteStride2 = 0;
int64_t byteStride3 = 0;
};
struct UsdDataArrayParams
{
// Even though we are not dealing with a usd-backed object, the data array can still have an identifying name.
// The pointer can then be used as id for resources (plus defining their filenames) such as textures,
// so they can be shared and still removed during garbage collection (after an UsdAnari object has already been destroyed).
// The persistence reason is why these strings have to be added to the string list of the device on construction.
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
};
class UsdDataArray : public UsdParameterizedBaseObject<UsdDataArray, UsdDataArrayParams>
{
public:
UsdDataArray(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userData,
ANARIDataType dataType,
uint64_t numItems1,
int64_t byteStride1,
uint64_t numItems2,
int64_t byteStride2,
uint64_t numItems3,
int64_t byteStride3,
UsdDevice* device
);
UsdDataArray(ANARIDataType dataType,
uint64_t numItems1,
uint64_t numItems2,
uint64_t numItems3,
UsdDevice* device
);
~UsdDataArray();
void filterSetParam(const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device) override;
int getProperty(const char *name,
ANARIDataType type,
void *mem,
uint64_t size,
UsdDevice* device) override;
void commit(UsdDevice* device) override;
void remove(UsdDevice* device) override {}
void* map(UsdDevice* device);
void unmap(UsdDevice* device);
void privatize();
const char* getName() const override { return UsdSharedString::c_str(getReadParams().usdName); }
const void* getData() const { return data; }
ANARIDataType getType() const { return type; }
const UsdDataLayout& getLayout() const { return layout; }
size_t getDataSizeInBytes() const { return dataSizeInBytes; }
protected:
bool deferCommit(UsdDevice* device) override { return false; }
bool doCommitData(UsdDevice* device) override { return false; }
void doCommitRefs(UsdDevice* device) override {}
void setLayoutAndSize(uint64_t numItems1,
int64_t byteStride1,
uint64_t numItems2,
int64_t byteStride2,
uint64_t numItems3,
int64_t byteStride3);
bool CheckFormatting(UsdDevice* device);
// Ref manipulation on arrays of anariobjects
void incRef(const ANARIObject* anariObjects, uint64_t numAnariObjects);
void decRef(const ANARIObject* anariObjects, uint64_t numAnariObjects);
// Private memory management
void allocPrivateData();
void freePrivateData(bool mappedCopy = false);
void freePublicData(const void* appMemory);
void publicToPrivateData();
// Mapped memory management
void CreateMappedObjectCopy();
void TransferAndRemoveMappedObjectCopy();
const void* data = nullptr;
ANARIMemoryDeleter dataDeleter = nullptr;
const void* deleterUserData = nullptr;
ANARIDataType type;
UsdDataLayout layout;
size_t dataSizeInBytes;
bool isPrivate;
const void* mappedObjectCopy;
#ifdef CHECK_MEMLEAKS
UsdDevice* allocDevice;
#endif
}; | 4,032 | C | 30.263566 | 138 | 0.708829 |
NVIDIA-Omniverse/AnariUsdDevice/UsdDeviceQueries.h | // Copyright 2021 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
// This file was generated by generate_queries.py
// Don't make changes to this directly
#include <anari/anari.h>
namespace anari {
namespace usd {
#define ANARI_INFO_required 0
#define ANARI_INFO_default 1
#define ANARI_INFO_minimum 2
#define ANARI_INFO_maximum 3
#define ANARI_INFO_description 4
#define ANARI_INFO_elementType 5
#define ANARI_INFO_value 6
#define ANARI_INFO_sourceExtension 7
#define ANARI_INFO_extension 8
#define ANARI_INFO_parameter 9
#define ANARI_INFO_channel 10
#define ANARI_INFO_use 11
const int extension_count = 17;
const char ** query_extensions();
const char ** query_object_types(ANARIDataType type);
const ANARIParameter * query_params(ANARIDataType type, const char *subtype);
const void * query_param_info_enum(ANARIDataType type, const char *subtype, const char *paramName, ANARIDataType paramType, int infoName, ANARIDataType infoType);
const void * query_param_info(ANARIDataType type, const char *subtype, const char *paramName, ANARIDataType paramType, const char *infoNameString, ANARIDataType infoType);
const void * query_object_info_enum(ANARIDataType type, const char *subtype, int infoName, ANARIDataType infoType);
const void * query_object_info(ANARIDataType type, const char *subtype, const char *infoNameString, ANARIDataType infoType);
}
}
| 1,368 | C | 41.781249 | 171 | 0.790205 |
NVIDIA-Omniverse/AnariUsdDevice/UsdDevice.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "anari/backend/DeviceImpl.h"
#include "anari/backend/LibraryImpl.h"
#include "UsdBaseObject.h"
#include <vector>
#include <memory>
#ifdef _WIN32
#ifdef anari_library_usd_EXPORTS
#define USDDevice_INTERFACE __declspec(dllexport)
#else
#define USDDevice_INTERFACE __declspec(dllimport)
#endif
#endif
extern "C"
{
#ifdef WIN32
USDDevice_INTERFACE void __cdecl anari_library_usd_init();
#else
void anari_library_usd_init();
#endif
}
class UsdDevice;
class UsdDeviceInternals;
class UsdBaseObject;
class UsdVolume;
struct UsdDeviceData
{
UsdSharedString* hostName = nullptr;
UsdSharedString* outputPath = nullptr;
bool createNewSession = true;
bool outputBinary = false;
bool writeAtCommit = false;
double timeStep = 0.0;
bool outputMaterial = true;
bool outputPreviewSurfaceShader = true;
bool outputMdlShader = true;
};
class UsdDevice : public anari::DeviceImpl, public UsdParameterizedBaseObject<UsdDevice, UsdDeviceData>
{
public:
UsdDevice();
UsdDevice(ANARILibrary library);
~UsdDevice();
///////////////////////////////////////////////////////////////////////////
// Main virtual interface to accepting API calls
///////////////////////////////////////////////////////////////////////////
// Data Arrays ////////////////////////////////////////////////////////////
ANARIArray1D newArray1D(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userdata,
ANARIDataType,
uint64_t numItems1) override;
ANARIArray2D newArray2D(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userdata,
ANARIDataType,
uint64_t numItems1,
uint64_t numItems2) override;
ANARIArray3D newArray3D(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userdata,
ANARIDataType,
uint64_t numItems1,
uint64_t numItems2,
uint64_t numItems3) override;
void* mapArray(ANARIArray) override;
void unmapArray(ANARIArray) override;
// Renderable Objects /////////////////////////////////////////////////////
ANARILight newLight(const char *type) override { return nullptr; }
ANARICamera newCamera(const char *type) override;
ANARIGeometry newGeometry(const char *type);
ANARISpatialField newSpatialField(const char *type) override;
ANARISurface newSurface() override;
ANARIVolume newVolume(const char *type) override;
// Model Meta-Data ////////////////////////////////////////////////////////
ANARIMaterial newMaterial(const char *material_type) override;
ANARISampler newSampler(const char *type) override;
// Instancing /////////////////////////////////////////////////////////////
ANARIGroup newGroup() override;
ANARIInstance newInstance(const char *type) override;
// Top-level Worlds ///////////////////////////////////////////////////////
ANARIWorld newWorld() override;
// Query functions ////////////////////////////////////////////////////////
const char ** getObjectSubtypes(ANARIDataType objectType) override;
const void* getObjectInfo(ANARIDataType objectType,
const char* objectSubtype,
const char* infoName,
ANARIDataType infoType) override;
const void* getParameterInfo(ANARIDataType objectType,
const char* objectSubtype,
const char* parameterName,
ANARIDataType parameterType,
const char* infoName,
ANARIDataType infoType) override;
// Object + Parameter Lifetime Management /////////////////////////////////
void setParameter(ANARIObject object,
const char *name,
ANARIDataType type,
const void *mem) override;
void unsetParameter(ANARIObject object, const char *name) override;
void unsetAllParameters(ANARIObject o) override;
void* mapParameterArray1D(ANARIObject o,
const char* name,
ANARIDataType dataType,
uint64_t numElements1,
uint64_t *elementStride) override;
void* mapParameterArray2D(ANARIObject o,
const char* name,
ANARIDataType dataType,
uint64_t numElements1,
uint64_t numElements2,
uint64_t *elementStride) override;
void* mapParameterArray3D(ANARIObject o,
const char* name,
ANARIDataType dataType,
uint64_t numElements1,
uint64_t numElements2,
uint64_t numElements3,
uint64_t *elementStride) override;
void unmapParameterArray(ANARIObject o,
const char* name) override;
void commitParameters(ANARIObject object) override;
void release(ANARIObject _obj) override;
void retain(ANARIObject _obj) override;
// Object Query Interface /////////////////////////////////////////////////
int getProperty(ANARIObject object,
const char *name,
ANARIDataType type,
void *mem,
uint64_t size,
uint32_t mask) override;
// FrameBuffer Manipulation ///////////////////////////////////////////////
ANARIFrame newFrame() override;
const void *frameBufferMap(ANARIFrame fb,
const char *channel,
uint32_t *width,
uint32_t *height,
ANARIDataType *pixelType) override;
void frameBufferUnmap(ANARIFrame fb, const char *channel) override;
// Frame Rendering ////////////////////////////////////////////////////////
ANARIRenderer newRenderer(const char *type) override;
void renderFrame(ANARIFrame frame) override;
int frameReady(ANARIFrame, ANARIWaitMask) override { return 1; }
void discardFrame(ANARIFrame) override {}
// UsdParameterizedBaseObject interface ///////////////////////////////////////////////////////////
void filterSetParam(
const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device) override;
void filterResetParam(
const char *name) override;
void commit(UsdDevice* device) override;
void remove(UsdDevice* device) override {}
// USD Specific ///////////////////////////////////////////////////////////
bool isInitialized() { return getUsdBridge() != nullptr; }
UsdBridge* getUsdBridge();
bool nameExists(const char* name);
void addToCommitList(UsdBaseObject* object, bool commitData);
bool isFlushingCommitList() const { return lockCommitList; }
void addToVolumeList(UsdVolume* volume);
void removeFromVolumeList(UsdVolume* volume);
// Allows for selected strings to persist,
// so their pointers can be cached beyond their containing objects' lifetimes,
// to be used for garbage collecting resource files.
void addToResourceStringList(UsdSharedString* sharedString);
#ifdef CHECK_MEMLEAKS
// Memleak checking
void LogObjAllocation(const UsdBaseObject* ptr);
void LogObjDeallocation(const UsdBaseObject* ptr);
std::vector<const UsdBaseObject*> allocatedObjects;
void LogStrAllocation(const UsdSharedString* ptr);
void LogStrDeallocation(const UsdSharedString* ptr);
std::vector<const UsdSharedString*> allocatedStrings;
void LogRawAllocation(const void* ptr);
void LogRawDeallocation(const void* ptr);
std::vector<const void*> allocatedRawMemory;
#endif
void reportStatus(void* source,
ANARIDataType sourceType,
ANARIStatusSeverity severity,
ANARIStatusCode statusCode,
const char *format, ...);
void reportStatus(void* source,
ANARIDataType sourceType,
ANARIStatusSeverity severity,
ANARIStatusCode statusCode,
const char *format,
va_list& arglist);
protected:
UsdBaseObject* getBaseObjectPtr(ANARIObject object);
// UsdParameterizedBaseObject interface ///////////////////////////////////////////////////////////
bool deferCommit(UsdDevice* device) { return false; };
bool doCommitData(UsdDevice* device) { return false; };
void doCommitRefs(UsdDevice* device) {};
// USD Specific Cleanup /////////////////////////////////////////////////////////////
void clearCommitList();
void flushCommitList();
void clearDeviceParameters();
void clearResourceStringList();
void initializeBridge();
const char* makeUniqueName(const char* name);
ANARIArray CreateDataArray(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userData,
ANARIDataType dataType,
uint64_t numItems1,
int64_t byteStride1,
uint64_t numItems2,
int64_t byteStride2,
uint64_t numItems3,
int64_t byteStride3);
template<int typeInt>
void writeTypeToUsd();
void removePrimsFromUsd(bool onlyRemoveHandles = false);
std::unique_ptr<UsdDeviceInternals> internals;
bool bridgeInitAttempt = false;
// Using object pointers as basis for deferred commits; another option would be to traverse
// the bridge's internal cache handles, but a handle may map to multiple objects (with the same name)
// so that's not 1-1 with the effects of a non-deferred commit order.
using CommitListType = std::pair<helium::IntrusivePtr<UsdBaseObject>, bool>;
std::vector<CommitListType> commitList;
std::vector<UsdBaseObject*> removeList;
std::vector<UsdVolume*> volumeList; // Tracks all volumes to auto-commit when child fields have been committed
bool lockCommitList = false;
std::vector<helium::IntrusivePtr<UsdSharedString>> resourceStringList;
ANARIStatusCallback statusFunc = nullptr;
const void* statusUserData = nullptr;
ANARIStatusCallback userSetStatusFunc = nullptr;
const void* userSetStatusUserData = nullptr;
std::vector<char> lastStatusMessage;
};
| 9,712 | C | 30.031949 | 114 | 0.643637 |
NVIDIA-Omniverse/AnariUsdDevice/UsdCamera.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBaseObject.h"
#include "UsdBridgedBaseObject.h"
enum class UsdCameraComponents
{
VIEW = 0,
PROJECTION
};
struct UsdCameraData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
int timeVarying = 0xFFFFFFFF; // TimeVarying bits
UsdFloat3 position = {0.0f, 0.0f, 0.0f};
UsdFloat3 direction = {0.0f, 0.0f, -1.0f};
UsdFloat3 up = {0.0f, 1.0f, 0.0f};
UsdFloatBox2 imageRegion = {0.0f, 0.0f, 1.0f, 1.0f};
// perspective/orthographic
float aspect = 1.0f;
float near = 1.0f;
float far = 10000;
float fovy = M_PI/3.0f;
float height = 1.0f;
};
class UsdCamera : public UsdBridgedBaseObject<UsdCamera, UsdCameraData, UsdCameraHandle, UsdCameraComponents>
{
public:
UsdCamera(const char* name, const char* type, UsdDevice* device);
~UsdCamera();
void remove(UsdDevice* device) override;
enum CameraType
{
CAMERA_UNKNOWN = 0,
CAMERA_PERSPECTIVE,
CAMERA_ORTHOGRAPHIC
};
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(UsdCameraComponents::VIEW, "view"),
ComponentPair(UsdCameraComponents::PROJECTION, "projection")};
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override {}
void copyParameters(UsdBridgeCameraData& camData);
CameraType cameraType = CAMERA_UNKNOWN;
}; | 1,521 | C | 23.548387 | 109 | 0.702827 |
NVIDIA-Omniverse/AnariUsdDevice/UsdDeviceUtils.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include <vector>
#include <memory>
template<typename ValueType, typename ContainerType = std::vector<ValueType>>
struct OptionalList
{
void ensureList()
{
if(!list)
list = std::make_unique<ContainerType>();
}
void clear()
{
if(list)
list->resize(0);
}
void push_back(const ValueType& value)
{
ensureList();
list->push_back(value);
}
void emplace_back(const ValueType& value)
{
ensureList();
list->emplace_back(value);
}
const ValueType* data()
{
if(list)
return list->data();
return nullptr;
}
size_t size()
{
if(list)
return list->size();
return 0;
}
std::unique_ptr<ContainerType> list;
}; | 796 | C | 14.627451 | 77 | 0.614322 |
NVIDIA-Omniverse/AnariUsdDevice/UsdSurface.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
#include <limits>
class UsdGeometry;
class UsdMaterial;
struct UsdSurfaceData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
// No timevarying data: geometry and material reference always set over all timesteps
UsdGeometry* geometry = nullptr;
UsdMaterial* material = nullptr;
double geometryRefTimeStep = std::numeric_limits<float>::quiet_NaN();
double materialRefTimeStep = std::numeric_limits<float>::quiet_NaN();
};
class UsdSurface : public UsdBridgedBaseObject<UsdSurface, UsdSurfaceData, UsdSurfaceHandle>
{
public:
UsdSurface(const char* name, UsdDevice* device);
~UsdSurface();
void remove(UsdDevice* device) override;
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override;
}; | 980 | C | 24.153846 | 92 | 0.753061 |
NVIDIA-Omniverse/AnariUsdDevice/UsdVolume.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
#include <limits>
class UsdSpatialField;
class UsdDevice;
class UsdDataArray;
enum class UsdVolumeComponents
{
COLOR = 0,
OPACITY,
VALUERANGE
};
struct UsdVolumeData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
int timeVarying = 0xFFFFFFFF; // Bitmask indicating which attributes are time-varying. (field reference always set over all timesteps)
UsdSpatialField* field = nullptr;
double fieldRefTimeStep = std::numeric_limits<float>::quiet_NaN();
bool preClassified = false;
//TF params
const UsdDataArray* color = nullptr;
const UsdDataArray* opacity = nullptr;
UsdFloatBox1 valueRange = { 0.0f, 1.0f };
float unitDistance = 1.0f;
};
class UsdVolume : public UsdBridgedBaseObject<UsdVolume, UsdVolumeData, UsdVolumeHandle, UsdVolumeComponents>
{
public:
UsdVolume(const char* name, UsdDevice* device);
~UsdVolume();
void remove(UsdDevice* device) override;
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(UsdVolumeComponents::COLOR, "color"),
ComponentPair(UsdVolumeComponents::OPACITY, "opacity"),
ComponentPair(UsdVolumeComponents::VALUERANGE, "valueRange")};
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override {}
bool CheckTfParams(UsdDevice* device);
bool UpdateVolume(UsdDevice* device, const char* debugName);
UsdSpatialField* prevField = nullptr;
UsdDevice* usdDevice = nullptr;
}; | 1,669 | C | 25.507936 | 136 | 0.742361 |
NVIDIA-Omniverse/AnariUsdDevice/UsdDataArray.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdDataArray.h"
#include "UsdDevice.h"
#include "UsdAnari.h"
#include "anari/frontend/type_utility.h"
DEFINE_PARAMETER_MAP(UsdDataArray,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
)
#define TO_OBJ_PTR reinterpret_cast<const ANARIObject*>
UsdDataArray::UsdDataArray(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userData,
ANARIDataType dataType,
uint64_t numItems1,
int64_t byteStride1,
uint64_t numItems2,
int64_t byteStride2,
uint64_t numItems3,
int64_t byteStride3,
UsdDevice* device
)
: UsdParameterizedBaseObject<UsdDataArray, UsdDataArrayParams>(ANARI_ARRAY)
, data(appMemory)
, dataDeleter(deleter)
, deleterUserData(userData)
, type(dataType)
, isPrivate(false)
#ifdef CHECK_MEMLEAKS
, allocDevice(device)
#endif
{
setLayoutAndSize(numItems1, byteStride1, numItems2, byteStride2, numItems3, byteStride3);
if (CheckFormatting(device))
{
// Make sure to incref all anari objects in case of object array
if (anari::isObject(type))
{
incRef(TO_OBJ_PTR(data), layout.numItems1);
}
}
}
UsdDataArray::UsdDataArray(ANARIDataType dataType, uint64_t numItems1, uint64_t numItems2, uint64_t numItems3, UsdDevice* device)
: UsdParameterizedBaseObject<UsdDataArray, UsdDataArrayParams>(ANARI_ARRAY)
, type(dataType)
, isPrivate(true)
#ifdef CHECK_MEMLEAKS
, allocDevice(device)
#endif
{
setLayoutAndSize(numItems1, 0, numItems2, 0, numItems3, 0);
if (CheckFormatting(device))
{
allocPrivateData();
}
}
UsdDataArray::~UsdDataArray()
{
// Decref anari objects in case of object array
if (anari::isObject(type))
{
decRef(TO_OBJ_PTR(data), layout.numItems1);
}
if (isPrivate)
{
freePrivateData();
}
else
{
freePublicData(data);
}
}
void UsdDataArray::filterSetParam(const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device)
{
if(setNameParam(name, type, mem, device))
device->addToResourceStringList(getWriteParams().usdName); //Name is kept for the lifetime of the device (to allow using pointer for caching resource's names)
}
int UsdDataArray::getProperty(const char * name, ANARIDataType type, void * mem, uint64_t size, UsdDevice* device)
{
int nameResult = getNameProperty(name, type, mem, size, device);
return nameResult;
}
void UsdDataArray::commit(UsdDevice* device)
{
if (anari::isObject(type) && (layout.numItems2 != 1 || layout.numItems3 != 1))
device->reportStatus(this, ANARI_ARRAY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdDataArray only supports one-dimensional ANARI_OBJECT arrays");
UsdParameterizedBaseObject<UsdDataArray, UsdDataArrayParams>::commit(device);
}
void * UsdDataArray::map(UsdDevice * device)
{
if (anari::isObject(type))
{
CreateMappedObjectCopy();
}
return const_cast<void *>(data);
}
void UsdDataArray::unmap(UsdDevice * device)
{
if (anari::isObject(type))
{
TransferAndRemoveMappedObjectCopy();
}
}
void UsdDataArray::privatize()
{
if(!isPrivate)
{
publicToPrivateData();
isPrivate = true;
}
}
void UsdDataArray::setLayoutAndSize(uint64_t numItems1,
int64_t byteStride1,
uint64_t numItems2,
int64_t byteStride2,
uint64_t numItems3,
int64_t byteStride3)
{
size_t typeSize = anari::sizeOf(type);
if (byteStride1 == 0)
byteStride1 = typeSize;
if (byteStride2 == 0)
byteStride2 = byteStride1 * numItems1;
if (byteStride3 == 0)
byteStride3 = byteStride2 * numItems2;
dataSizeInBytes = byteStride3 * numItems3 - (byteStride1 - typeSize);
layout = { typeSize, numItems1, numItems2, numItems3, byteStride1, byteStride2, byteStride3 };
}
bool UsdDataArray::CheckFormatting(UsdDevice* device)
{
if (anari::isObject(type))
{
if (!layout.isDense() || !layout.isOneDimensional())
{
device->reportStatus(this, ANARI_ARRAY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdDataArray construction failed: arrays with object type have to be one dimensional and without stride.");
layout.numItems1 = layout.numItems2 = layout.numItems3 = 0;
data = nullptr;
type = ANARI_UNKNOWN;
return false;
}
}
return true;
}
void UsdDataArray::incRef(const ANARIObject* anariObjects, uint64_t numAnariObjects)
{
for (int i = 0; i < numAnariObjects; ++i)
{
const UsdBaseObject* baseObj = (reinterpret_cast<const UsdBaseObject*>(anariObjects[i]));
if (baseObj)
baseObj->refInc(helium::RefType::INTERNAL);
}
}
void UsdDataArray::decRef(const ANARIObject* anariObjects, uint64_t numAnariObjects)
{
for (int i = 0; i < numAnariObjects; ++i)
{
const UsdBaseObject* baseObj = (reinterpret_cast<const UsdBaseObject*>(anariObjects[i]));
#ifdef CHECK_MEMLEAKS
allocDevice->LogObjDeallocation(baseObj);
#endif
if (baseObj)
{
assert(baseObj->useCount(helium::RefType::INTERNAL) > 0);
baseObj->refDec(helium::RefType::INTERNAL);
}
}
}
void UsdDataArray::allocPrivateData()
{
// Alloc the owned memory
char* newData = new char[dataSizeInBytes];
memset(newData, 0, dataSizeInBytes);
data = newData;
#ifdef CHECK_MEMLEAKS
allocDevice->LogRawAllocation(newData);
#endif
}
void UsdDataArray::freePrivateData(bool mappedCopy)
{
const void*& memToFree = mappedCopy ? mappedObjectCopy : data;
#ifdef CHECK_MEMLEAKS
allocDevice->LogRawDeallocation(memToFree);
#endif
// Deallocate owned memory
delete[](char*)memToFree;
memToFree = nullptr;
}
void UsdDataArray::freePublicData(const void* appMemory)
{
if (dataDeleter)
{
dataDeleter(deleterUserData, appMemory);
dataDeleter = nullptr;
}
}
void UsdDataArray::publicToPrivateData()
{
// Alloc private dest, copy appMemory src to it
const void* appMemory = data;
allocPrivateData();
std::memcpy(const_cast<void *>(data), appMemory, dataSizeInBytes); // In case of object array, Refcount 'transfers' to the copy (splits off user-managed public refcount)
// Delete appMemory if appropriate
freePublicData(appMemory);
// No refcount modification necessary, public refcount managed by user
}
void UsdDataArray::CreateMappedObjectCopy()
{
// Move the original array to a different spot and allocate new memory for the mapped object array.
mappedObjectCopy = data;
allocPrivateData();
// Transfer contents over to new memory, keep old one for managing references later on.
std::memcpy(const_cast<void *>(data), mappedObjectCopy, dataSizeInBytes);
}
void UsdDataArray::TransferAndRemoveMappedObjectCopy()
{
const ANARIObject* newAnariObjects = TO_OBJ_PTR(data);
const ANARIObject* oldAnariObjects = TO_OBJ_PTR(mappedObjectCopy);
uint64_t numAnariObjects = layout.numItems1;
// First, increase reference counts of all objects that different in the new object array
for (int i = 0; i < numAnariObjects; ++i)
{
const UsdBaseObject* newObj = (reinterpret_cast<const UsdBaseObject*>(newAnariObjects[i]));
const UsdBaseObject* oldObj = (reinterpret_cast<const UsdBaseObject*>(oldAnariObjects[i]));
if (newObj != oldObj && newObj)
newObj->refInc(helium::RefType::INTERNAL);
}
// Then, decrease reference counts of all objects that are different in the original array (which will delete those that not referenced anymore)
for (int i = 0; i < numAnariObjects; ++i)
{
const UsdBaseObject* newObj = (reinterpret_cast<const UsdBaseObject*>(newAnariObjects[i]));
const UsdBaseObject* oldObj = (reinterpret_cast<const UsdBaseObject*>(oldAnariObjects[i]));
if (newObj != oldObj && oldObj)
{
#ifdef CHECK_MEMLEAKS
allocDevice->LogObjDeallocation(oldObj);
#endif
oldObj->refDec(helium::RefType::INTERNAL);
}
}
// Release the mapped object copy's allocated memory
freePrivateData(true);
}
| 7,904 | C++ | 26.258621 | 207 | 0.721407 |
NVIDIA-Omniverse/AnariUsdDevice/UsdInstance.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdInstance.h"
#include "UsdAnari.h"
#include "UsdDevice.h"
#include "UsdGroup.h"
#define GroupType ANARI_GROUP
using GroupUsdType = AnariToUsdBridgedObject<GroupType>::Type;
DEFINE_PARAMETER_MAP(UsdInstance,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("group", GroupType, group)
REGISTER_PARAMETER_MACRO("transform", ANARI_FLOAT32_MAT4, transform)
)
constexpr UsdInstance::ComponentPair UsdInstance::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
UsdInstance::UsdInstance(const char* name,
UsdDevice* device)
: BridgedBaseObjectType(ANARI_INSTANCE, name, device)
{
}
UsdInstance::~UsdInstance()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
if(cachedBridge)
cachedBridge->DeleteInstance(usdHandle);
#endif
}
void UsdInstance::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteInstance);
}
bool UsdInstance::deferCommit(UsdDevice* device)
{
const UsdInstanceData& paramData = getReadParams();
if(UsdObjectNotInitialized<GroupUsdType>(paramData.group))
{
return true;
}
return false;
}
bool UsdInstance::doCommitData(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const char* instanceName = getName();
bool isNew = false;
if (!usdHandle.value)
isNew = usdBridge->CreateInstance(instanceName, usdHandle);
if (paramChanged || isNew)
{
doCommitRefs(device); // Perform immediate commit of refs - no params from children required
paramChanged = false;
}
return false;
}
void UsdInstance::doCommitRefs(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdInstanceData& paramData = getReadParams();
double timeStep = device->getReadParams().timeStep;
bool groupTimeVarying = isTimeVarying(UsdInstanceComponents::GROUP);
bool transformTimeVarying = isTimeVarying(UsdInstanceComponents::TRANSFORM);
if (paramData.group)
{
usdBridge->SetGroupRef(usdHandle, paramData.group->getUsdHandle(), groupTimeVarying, timeStep);
}
else
{
usdBridge->DeleteGroupRef(usdHandle, groupTimeVarying, timeStep);
}
usdBridge->SetInstanceTransform(usdHandle, paramData.transform.Data, transformTimeVarying, timeStep);
} | 2,456 | C++ | 25.706521 | 132 | 0.757329 |
NVIDIA-Omniverse/AnariUsdDevice/UsdGeometry.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdGeometry.h"
#include "UsdAnari.h"
#include "UsdDataArray.h"
#include "UsdDevice.h"
#include "UsdBridgeUtils.h"
#include "anari/frontend/type_utility.h"
#include <cmath>
DEFINE_PARAMETER_MAP(UsdGeometry,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::time", ANARI_FLOAT64, timeStep)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("usd::time.shapeGeometry", ANARI_FLOAT64, shapeGeometryRefTimeStep)
REGISTER_PARAMETER_MACRO("usd::useUsdGeomPoints", ANARI_BOOL, UseUsdGeomPoints)
REGISTER_PARAMETER_MACRO("primitive.index", ANARI_ARRAY, indices)
REGISTER_PARAMETER_MACRO("primitive.normal", ANARI_ARRAY, primitiveNormals)
REGISTER_PARAMETER_MACRO("primitive.color", ANARI_ARRAY, primitiveColors)
REGISTER_PARAMETER_MACRO("primitive.radius", ANARI_ARRAY, primitiveRadii)
REGISTER_PARAMETER_MACRO("primitive.scale", ANARI_ARRAY, primitiveScales)
REGISTER_PARAMETER_MACRO("primitive.orientation", ANARI_ARRAY, primitiveOrientations)
REGISTER_PARAMETER_ARRAY_MACRO("primitive.attribute", "", ANARI_ARRAY, primitiveAttributes, MAX_ATTRIBS)
REGISTER_PARAMETER_MACRO("primitive.id", ANARI_ARRAY, primitiveIds)
REGISTER_PARAMETER_MACRO("vertex.position", ANARI_ARRAY, vertexPositions)
REGISTER_PARAMETER_MACRO("vertex.normal", ANARI_ARRAY, vertexNormals)
REGISTER_PARAMETER_MACRO("vertex.color", ANARI_ARRAY, vertexColors)
REGISTER_PARAMETER_MACRO("vertex.radius", ANARI_ARRAY, vertexRadii)
REGISTER_PARAMETER_MACRO("vertex.scale", ANARI_ARRAY, vertexScales)
REGISTER_PARAMETER_MACRO("vertex.orientation", ANARI_ARRAY, vertexOrientations)
REGISTER_PARAMETER_ARRAY_MACRO("vertex.attribute", "", ANARI_ARRAY, vertexAttributes, MAX_ATTRIBS)
REGISTER_PARAMETER_ARRAY_MACRO("usd::attribute", ".name", ANARI_STRING, attributeNames, MAX_ATTRIBS)
REGISTER_PARAMETER_MACRO("radius", ANARI_FLOAT32, radiusConstant)
REGISTER_PARAMETER_MACRO("scale", ANARI_FLOAT32_VEC3, scaleConstant)
REGISTER_PARAMETER_MACRO("orientation", ANARI_FLOAT32_QUAT_IJKW, orientationConstant)
REGISTER_PARAMETER_MACRO("shapeType", ANARI_STRING, shapeType)
REGISTER_PARAMETER_MACRO("shapeGeometry", ANARI_GEOMETRY, shapeGeometry)
REGISTER_PARAMETER_MACRO("shapeTransform", ANARI_FLOAT32_MAT4, shapeTransform)
) // See .h for usage.
constexpr UsdGeometry::ComponentPair UsdGeometry::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
struct UsdGeometryTempArrays
{
UsdGeometryTempArrays(const UsdGeometry::AttributeArray& attributes)
: Attributes(attributes)
{}
std::vector<int> CurveLengths;
std::vector<float> PointsArray;
std::vector<float> NormalsArray;
std::vector<float> RadiiArray;
std::vector<float> ScalesArray;
std::vector<float> OrientationsArray;
std::vector<int64_t> IdsArray;
std::vector<int64_t> InvisIdsArray;
std::vector<char> ColorsArray; // generic byte array
ANARIDataType ColorsArrayType;
UsdGeometry::AttributeDataArraysType AttributeDataArrays;
const UsdGeometry::AttributeArray& Attributes;
void resetColorsArray(size_t numElements, ANARIDataType type)
{
ColorsArray.resize(numElements*anari::sizeOf(type));
ColorsArrayType = type;
}
void reserveColorsArray(size_t numElements)
{
ColorsArray.reserve(numElements*anari::sizeOf(ColorsArrayType));
}
size_t expandColorsArray(size_t numElements)
{
size_t startByte = ColorsArray.size();
size_t typeSize = anari::sizeOf(ColorsArrayType);
ColorsArray.resize(startByte+numElements*typeSize);
return startByte/typeSize;
}
void copyToColorsArray(const void* source, size_t srcIdx, size_t destIdx, size_t numElements)
{
size_t typeSize = anari::sizeOf(ColorsArrayType);
size_t srcStart = srcIdx*typeSize;
size_t dstStart = destIdx*typeSize;
size_t numBytes = numElements*typeSize;
assert(dstStart+numBytes <= ColorsArray.size());
memcpy(ColorsArray.data()+dstStart, reinterpret_cast<const char*>(source)+srcStart, numBytes);
}
void resetAttributeDataArray(size_t attribIdx, size_t numElements)
{
if(Attributes[attribIdx].Data)
{
uint32_t eltSize = Attributes[attribIdx].EltSize;
AttributeDataArrays[attribIdx].resize(numElements*eltSize);
}
else
AttributeDataArrays[attribIdx].resize(0);
}
void reserveAttributeDataArray(size_t attribIdx, size_t numElements)
{
if(Attributes[attribIdx].Data)
{
uint32_t eltSize = Attributes[attribIdx].EltSize;
AttributeDataArrays[attribIdx].reserve(numElements*eltSize);
}
}
size_t expandAttributeDataArray(size_t attribIdx, size_t numElements)
{
if(Attributes[attribIdx].Data)
{
uint32_t eltSize = Attributes[attribIdx].EltSize;
size_t startByte = AttributeDataArrays[attribIdx].size();
AttributeDataArrays[attribIdx].resize(startByte+numElements*eltSize);
return startByte/eltSize;
}
return 0;
}
void copyToAttributeDataArray(size_t attribIdx, size_t srcIdx, size_t destIdx, size_t numElements)
{
if(Attributes[attribIdx].Data)
{
uint32_t eltSize = Attributes[attribIdx].EltSize;
const void* attribSrc = reinterpret_cast<const char*>(Attributes[attribIdx].Data) + srcIdx*eltSize;
size_t dstStart = destIdx*eltSize;
size_t numBytes = numElements*eltSize;
assert(dstStart+numBytes <= AttributeDataArrays[attribIdx].size());
void* attribDest = &AttributeDataArrays[attribIdx][dstStart];
memcpy(attribDest, attribSrc, numElements*eltSize);
}
}
};
namespace
{
struct UsdGeometryDebugData
{
UsdDevice* device = nullptr;
UsdGeometry* geometry = nullptr;
const char* debugName = nullptr;
};
UsdGeometry::GeomType GetGeomType(const char* type)
{
UsdGeometry::GeomType geomType;
if (strEquals(type, "sphere"))
geomType = UsdGeometry::GEOM_SPHERE;
else if (strEquals(type, "cylinder"))
geomType = UsdGeometry::GEOM_CYLINDER;
else if (strEquals(type, "cone"))
geomType = UsdGeometry::GEOM_CONE;
else if (strEquals(type, "curve"))
geomType = UsdGeometry::GEOM_CURVE;
else if(strEquals(type, "triangle"))
geomType = UsdGeometry::GEOM_TRIANGLE;
else if (strEquals(type, "quad"))
geomType = UsdGeometry::GEOM_QUAD;
else if (strEquals(type, "glyph"))
geomType = UsdGeometry::GEOM_GLYPH;
else
geomType = UsdGeometry::GEOM_UNKNOWN;
return geomType;
}
uint64_t GetNumberOfPrims(bool hasIndices, const UsdDataLayout& indexLayout, UsdGeometry::GeomType geomType)
{
if(geomType == UsdGeometry::GEOM_CURVE)
return indexLayout.numItems1 - 1;
else if(hasIndices)
return indexLayout.numItems1;
int perPrimVertexCount = 1;
switch(geomType)
{
case UsdGeometry::GEOM_CYLINDER:
case UsdGeometry::GEOM_CONE:
perPrimVertexCount = 2;
break;
case UsdGeometry::GEOM_TRIANGLE:
perPrimVertexCount = 3;
break;
case UsdGeometry::GEOM_QUAD:
perPrimVertexCount = 4;
break;
default: break;
};
return indexLayout.numItems1 / perPrimVertexCount;
}
bool isBitSet(int value, int bit)
{
return (bool)(value & (1 << bit));
}
size_t getIndex(const void* indices, ANARIDataType type, size_t elt)
{
size_t result;
switch (type)
{
case ANARI_INT32:
case ANARI_INT32_VEC2:
result = (reinterpret_cast<const int*>(indices))[elt];
break;
case ANARI_UINT32:
case ANARI_UINT32_VEC2:
result = (reinterpret_cast<const uint32_t*>(indices))[elt];
break;
case ANARI_INT64:
case ANARI_INT64_VEC2:
result = (reinterpret_cast<const int64_t*>(indices))[elt];
break;
case ANARI_UINT64:
case ANARI_UINT64_VEC2:
result = (reinterpret_cast<const uint64_t*>(indices))[elt];
break;
default:
result = 0;
break;
}
return result;
}
void getValues1(const void* vertices, ANARIDataType type, size_t idx, float* result)
{
if (type == ANARI_FLOAT32)
{
const float* vertf = reinterpret_cast<const float*>(vertices);
result[0] = vertf[idx];
}
else if (type == ANARI_FLOAT64)
{
const double* vertd = reinterpret_cast<const double*>(vertices);
result[0] = (float)vertd[idx];
}
}
void getValues2(const void* vertices, ANARIDataType type, size_t idx, float* result)
{
if (type == ANARI_FLOAT32_VEC2)
{
const float* vertf = reinterpret_cast<const float*>(vertices);
result[0] = vertf[idx * 2];
result[1] = vertf[idx * 2 + 1];
}
else if (type == ANARI_FLOAT64_VEC2)
{
const double* vertd = reinterpret_cast<const double*>(vertices);
result[0] = (float)vertd[idx * 2];
result[1] = (float)vertd[idx * 2 + 1];
}
}
void getValues3(const void* vertices, ANARIDataType type, size_t idx, float* result)
{
if (type == ANARI_FLOAT32_VEC3)
{
const float* vertf = reinterpret_cast<const float*>(vertices);
result[0] = vertf[idx * 3];
result[1] = vertf[idx * 3 + 1];
result[2] = vertf[idx * 3 + 2];
}
else if (type == ANARI_FLOAT64_VEC3)
{
const double* vertd = reinterpret_cast<const double*>(vertices);
result[0] = (float)vertd[idx * 3];
result[1] = (float)vertd[idx * 3 + 1];
result[2] = (float)vertd[idx * 3 + 2];
}
}
void getValues4(const void* vertices, ANARIDataType type, size_t idx, float* result)
{
if (type == ANARI_FLOAT32_VEC4)
{
const float* vertf = reinterpret_cast<const float*>(vertices);
result[0] = vertf[idx * 4];
result[1] = vertf[idx * 4 + 1];
result[2] = vertf[idx * 4 + 2];
result[3] = vertf[idx * 4 + 3];
}
else if (type == ANARI_FLOAT64_VEC4)
{
const double* vertd = reinterpret_cast<const double*>(vertices);
result[0] = (float)vertd[idx * 4];
result[1] = (float)vertd[idx * 4 + 1];
result[2] = (float)vertd[idx * 4 + 2];
result[3] = (float)vertd[idx * 4 + 3];
}
}
void generateIndexedSphereData(const UsdGeometryData& paramData, const UsdGeometry::AttributeArray& attributeArray, UsdGeometryTempArrays* tempArrays)
{
if (paramData.indices)
{
auto& attribDataArrays = tempArrays->AttributeDataArrays;
assert(attribDataArrays.size() == attributeArray.size());
uint64_t numVertices = paramData.vertexPositions->getLayout().numItems1;
ANARIDataType scaleType = paramData.vertexScales ? paramData.vertexScales->getType()
: (paramData.primitiveScales ? paramData.primitiveScales->getType() : ANARI_UNKNOWN);
size_t scaleComps = anari::componentsOf(scaleType);
bool perPrimNormals = !paramData.vertexNormals && paramData.primitiveNormals;
bool perPrimRadii = !paramData.vertexRadii && paramData.primitiveRadii;
bool perPrimScales = !paramData.vertexScales && paramData.primitiveScales;
bool perPrimColors = !paramData.vertexColors && paramData.primitiveColors;
bool perPrimOrientations = !paramData.vertexOrientations && paramData.primitiveOrientations;
ANARIDataType colorType = perPrimColors ? paramData.primitiveColors->getType() : ANARI_UINT8; // Vertex colors aren't reordered
// Effectively only has to reorder if the source array is perPrim, otherwise this function effectively falls through and the source array is assigned directly at parent scope.
tempArrays->NormalsArray.resize(perPrimNormals ? numVertices*3 : 0);
tempArrays->RadiiArray.resize(perPrimScales ? numVertices : 0);
tempArrays->ScalesArray.resize(perPrimScales ? numVertices*scaleComps : 0);
tempArrays->OrientationsArray.resize(perPrimOrientations ? numVertices*4 : 0);
tempArrays->IdsArray.resize(numVertices, -1); // Always filled, since indices implies necessity for invisibleIds, and therefore also an Id array
tempArrays->resetColorsArray(perPrimColors ? numVertices : 0, colorType);
for(size_t attribIdx = 0; attribIdx < attribDataArrays.size(); ++attribIdx)
{
tempArrays->resetAttributeDataArray(attribIdx, attributeArray[attribIdx].PerPrimData ? numVertices : 0);
}
const void* indices = paramData.indices->getData();
uint64_t numIndices = paramData.indices->getLayout().numItems1;
ANARIDataType indexType = paramData.indices->getType();
int64_t maxId = -1;
for (uint64_t primIdx = 0; primIdx < numIndices; ++primIdx)
{
size_t vertIdx = getIndex(indices, indexType, primIdx);
// Normals
if (perPrimNormals)
{
float* normalsDest = &tempArrays->NormalsArray[vertIdx * 3];
getValues3(paramData.primitiveNormals->getData(), paramData.primitiveNormals->getType(), primIdx, normalsDest);
}
// Orientations
if (perPrimOrientations)
{
float* orientsDest = &tempArrays->OrientationsArray[vertIdx*4];
getValues4(paramData.primitiveOrientations->getData(), paramData.primitiveOrientations->getType(), primIdx, orientsDest);
}
// Radii
if (perPrimRadii)
{
float* radiiDest = &tempArrays->RadiiArray[vertIdx];
getValues1(paramData.primitiveRadii->getData(), paramData.primitiveRadii->getType(), primIdx, radiiDest);
}
// Scales
if (perPrimScales)
{
float* scalesDest = &tempArrays->ScalesArray[vertIdx*scaleComps];
if(scaleComps == 1)
getValues1(paramData.primitiveScales->getData(), paramData.primitiveScales->getType(), primIdx, scalesDest);
else if(scaleComps == 3)
getValues3(paramData.primitiveScales->getData(), paramData.primitiveScales->getType(), primIdx, scalesDest);
}
// Colors
if (perPrimColors)
{
assert(primIdx < paramData.primitiveColors->getLayout().numItems1);
tempArrays->copyToColorsArray(paramData.primitiveColors->getData(), primIdx, vertIdx, 1);
}
// Attributes
for(size_t attribIdx = 0; attribIdx < attribDataArrays.size(); ++attribIdx)
{
if(attributeArray[attribIdx].PerPrimData)
{
tempArrays->copyToAttributeDataArray(attribIdx, primIdx, vertIdx, 1);
}
}
// Ids
if (paramData.primitiveIds)
{
int64_t id = static_cast<int64_t>(getIndex(paramData.primitiveIds->getData(), paramData.primitiveIds->getType(), primIdx));
tempArrays->IdsArray[vertIdx] = id;
if (id > maxId)
maxId = id;
}
else
{
int64_t id = static_cast<int64_t>(vertIdx);
maxId = tempArrays->IdsArray[vertIdx] = id;
}
}
// Assign unused ids to untouched vertices, then add those ids to invisible array
tempArrays->InvisIdsArray.resize(0);
tempArrays->InvisIdsArray.reserve(numVertices);
for (uint64_t vertIdx = 0; vertIdx < numVertices; ++vertIdx)
{
if (tempArrays->IdsArray[vertIdx] == -1)
{
tempArrays->IdsArray[vertIdx] = ++maxId;
tempArrays->InvisIdsArray.push_back(maxId);
}
}
}
}
void convertLinesToSticks(const UsdGeometryData& paramData, const UsdGeometry::AttributeArray& attributeArray, UsdGeometryTempArrays* tempArrays)
{
// Converts arrays of vertex endpoint 2-tuples (optionally obtained via index 2-tuples) into center vertices with correct seglengths.
auto& attribDataArrays = tempArrays->AttributeDataArrays;
assert(attribDataArrays.size() == attributeArray.size());
const UsdDataArray* vertexArray = paramData.vertexPositions;
uint64_t numVertices = vertexArray->getLayout().numItems1;
const void* vertices = vertexArray->getData();
ANARIDataType vertexType = vertexArray->getType();
const UsdDataArray* indexArray = paramData.indices;
uint64_t numSticks = indexArray ? indexArray->getLayout().numItems1 : numVertices/2;
uint64_t numIndices = numSticks * 2; // Indices are 2-element vectors in ANARI
const void* indices = indexArray ? indexArray->getData() : nullptr;
ANARIDataType indexType = indexArray ? indexArray->getType() : ANARI_UINT32;
tempArrays->PointsArray.resize(numSticks * 3);
tempArrays->ScalesArray.resize(numSticks * 3); // Scales are always present
tempArrays->OrientationsArray.resize(numSticks * 4);
tempArrays->IdsArray.resize(paramData.primitiveIds ? numSticks : 0);
// Only reorder per-vertex arrays, per-prim is already in order of the output stick center vertices
ANARIDataType colorType = paramData.vertexColors ? paramData.vertexColors->getType() : ANARI_UINT8;
tempArrays->resetColorsArray(paramData.vertexColors ? numSticks : 0, colorType);
for(size_t attribIdx = 0; attribIdx < attribDataArrays.size(); ++attribIdx)
{
tempArrays->resetAttributeDataArray(attribIdx, !attributeArray[attribIdx].PerPrimData ? numSticks : 0);
}
for (size_t i = 0; i < numIndices; i += 2)
{
size_t primIdx = i / 2;
size_t vertIdx0 = indices ? getIndex(indices, indexType, i) : i;
size_t vertIdx1 = indices ? getIndex(indices, indexType, i + 1) : i + 1;
assert(vertIdx0 < numVertices);
assert(vertIdx1 < numVertices);
float point0[3], point1[3];
getValues3(vertices, vertexType, vertIdx0, point0);
getValues3(vertices, vertexType, vertIdx1, point1);
tempArrays->PointsArray[primIdx * 3] = (point0[0] + point1[0]) * 0.5f;
tempArrays->PointsArray[primIdx * 3 + 1] = (point0[1] + point1[1]) * 0.5f;
tempArrays->PointsArray[primIdx * 3 + 2] = (point0[2] + point1[2]) * 0.5f;
float scaleVal = paramData.radiusConstant;
if (paramData.vertexRadii)
{
getValues1(paramData.vertexRadii->getData(), paramData.vertexRadii->getType(), vertIdx0, &scaleVal);
}
else if (paramData.primitiveRadii)
{
getValues1(paramData.primitiveRadii->getData(), paramData.primitiveRadii->getType(), primIdx, &scaleVal);
}
float segDir[3] = {
point1[0] - point0[0],
point1[1] - point0[1],
point1[2] - point0[2],
};
float segLength = sqrtf(segDir[0] * segDir[0] + segDir[1] * segDir[1] + segDir[2] * segDir[2]);
tempArrays->ScalesArray[primIdx * 3] = scaleVal;
tempArrays->ScalesArray[primIdx * 3 + 1] = scaleVal;
tempArrays->ScalesArray[primIdx * 3 + 2] = segLength * 0.5f;
// Rotation
// USD shapes are always lengthwise-oriented along the z axis
usdbridgenumerics::DirectionToQuaternionZ(segDir, segLength, tempArrays->OrientationsArray.data() + primIdx*4);
//Colors
if (paramData.vertexColors)
{
assert(vertIdx0 < paramData.vertexColors->getLayout().numItems1);
tempArrays->copyToColorsArray(paramData.vertexColors->getData(), vertIdx0, primIdx, 1);
}
// Attributes
for(size_t attribIdx = 0; attribIdx < attribDataArrays.size(); ++attribIdx)
{
if(!attributeArray[attribIdx].PerPrimData)
{
tempArrays->copyToAttributeDataArray(attribIdx, vertIdx0, primIdx, 1);
}
}
// Ids
if (paramData.primitiveIds)
{
tempArrays->IdsArray[primIdx] = (int64_t)getIndex(paramData.primitiveIds->getData(), paramData.primitiveIds->getType(), primIdx);
}
}
}
void pushVertex(const UsdGeometryData& paramData, const UsdGeometry::AttributeArray& attributeArray, UsdGeometryTempArrays* tempArrays,
const void* vertices, ANARIDataType vertexType,
bool hasNormals, bool hasColors, bool hasRadii,
size_t segStart, size_t primIdx)
{
auto& attribDataArrays = tempArrays->AttributeDataArrays;
float point[3];
getValues3(vertices, vertexType, segStart, point);
tempArrays->PointsArray.push_back(point[0]);
tempArrays->PointsArray.push_back(point[1]);
tempArrays->PointsArray.push_back(point[2]);
// Normals
if (hasNormals)
{
float normals[3];
if (paramData.vertexNormals)
{
getValues3(paramData.vertexNormals->getData(), paramData.vertexNormals->getType(), segStart, normals);
}
else if (paramData.primitiveNormals)
{
getValues3(paramData.primitiveNormals->getData(), paramData.primitiveNormals->getType(), primIdx, normals);
}
tempArrays->NormalsArray.push_back(normals[0]);
tempArrays->NormalsArray.push_back(normals[1]);
tempArrays->NormalsArray.push_back(normals[2]);
}
// Radii
if (hasRadii)
{
float radii;
if (paramData.vertexRadii)
{
getValues1(paramData.vertexRadii->getData(), paramData.vertexRadii->getType(), segStart, &radii);
}
else if (paramData.primitiveRadii)
{
getValues1(paramData.primitiveRadii->getData(), paramData.primitiveRadii->getType(), primIdx, &radii);
}
tempArrays->ScalesArray.push_back(radii);
}
// Colors
if (hasColors)
{
size_t destIdx = tempArrays->expandColorsArray(1);
if (paramData.vertexColors)
{
tempArrays->copyToColorsArray(paramData.vertexColors->getData(), segStart, destIdx, 1);
}
else if (paramData.primitiveColors)
{
tempArrays->copyToColorsArray(paramData.primitiveColors->getData(), primIdx, destIdx, 1);
}
}
// Attributes
for(size_t attribIdx = 0; attribIdx < attribDataArrays.size(); ++attribIdx)
{
size_t srcIdx = attributeArray[attribIdx].PerPrimData ? primIdx : segStart;
size_t destIdx = tempArrays->expandAttributeDataArray(attribIdx, 1);
tempArrays->copyToAttributeDataArray(attribIdx, srcIdx, destIdx, 1);
}
}
#define PUSH_VERTEX(x, y) \
pushVertex(paramData, attributeArray, tempArrays, \
vertices, vertexType, \
hasNormals, hasColors, hasRadii, \
x, y)
void reorderCurveGeometry(const UsdGeometryData& paramData, const UsdGeometry::AttributeArray& attributeArray, UsdGeometryTempArrays* tempArrays)
{
auto& attribDataArrays = tempArrays->AttributeDataArrays;
assert(attribDataArrays.size() == attributeArray.size());
const UsdDataArray* vertexArray = paramData.vertexPositions;
uint64_t numVertices = vertexArray->getLayout().numItems1;
const void* vertices = vertexArray->getData();
ANARIDataType vertexType = vertexArray->getType();
const UsdDataArray* indexArray = paramData.indices;
uint64_t numSegments = indexArray ? indexArray->getLayout().numItems1 : numVertices-1;
const void* indices = indexArray ? indexArray->getData() : nullptr;
ANARIDataType indexType = indexArray ? indexArray->getType() : ANARI_UINT32;
uint64_t maxNumVerts = numSegments*2;
tempArrays->CurveLengths.resize(0);
tempArrays->PointsArray.resize(0);
tempArrays->PointsArray.reserve(maxNumVerts * 3); // Conservative max number of points
bool hasNormals = paramData.vertexNormals || paramData.primitiveNormals;
if (hasNormals)
{
tempArrays->NormalsArray.resize(0);
tempArrays->NormalsArray.reserve(maxNumVerts * 3);
}
bool hasColors = paramData.vertexColors || paramData.primitiveColors;
if (hasColors)
{
tempArrays->resetColorsArray(0, paramData.vertexColors ? paramData.vertexColors->getType() : paramData.primitiveColors->getType());
tempArrays->reserveColorsArray(maxNumVerts);
}
bool hasRadii = paramData.vertexRadii || paramData.primitiveRadii;
if (hasRadii)
{
tempArrays->ScalesArray.resize(0);
tempArrays->ScalesArray.reserve(maxNumVerts);
}
for(size_t attribIdx = 0; attribIdx < attribDataArrays.size(); ++attribIdx)
{
tempArrays->resetAttributeDataArray(attribIdx, 0);
tempArrays->reserveAttributeDataArray(attribIdx, maxNumVerts);
}
size_t prevSegEnd = 0;
int curveLength = 0;
for (size_t primIdx = 0; primIdx < numSegments; ++primIdx)
{
size_t segStart = indices ? getIndex(indices, indexType, primIdx) : primIdx;
if (primIdx != 0 && prevSegEnd != segStart)
{
PUSH_VERTEX(prevSegEnd, primIdx - 1);
curveLength += 1;
tempArrays->CurveLengths.push_back(curveLength);
curveLength = 0;
}
assert(segStart+1 < numVertices); // begin and end vertex should be in range
PUSH_VERTEX(segStart, primIdx);
curveLength += 1;
prevSegEnd = segStart + 1;
}
if (curveLength != 0)
{
PUSH_VERTEX(prevSegEnd, numSegments - 1);
curveLength += 1;
tempArrays->CurveLengths.push_back(curveLength);
}
}
template<typename T>
void setInstancerDataArray(const char* arrayName, const UsdDataArray* vertArray, const UsdDataArray* primArray, const std::vector<T>& tmpArray, UsdBridgeType tmpArrayType,
void const*& instancerDataArray, UsdBridgeType& instancerDataArrayType, const UsdGeometryData& paramData, const UsdGeometryDebugData& dbgData)
{
// Normals
if (paramData.indices && tmpArray.size())
{
instancerDataArray = tmpArray.data();
instancerDataArrayType = tmpArrayType;
}
else
{
const UsdDataArray* normals = vertArray;
if (normals)
{
instancerDataArray = normals->getData();
instancerDataArrayType = AnariToUsdBridgeType(normals->getType());
}
else if(primArray)
{
dbgData.device->reportStatus(dbgData.geometry, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdGeometry '%s' primitive.%s not transferred: per-primitive arrays provided without setting primitive.index", dbgData.debugName, arrayName);
}
}
}
}
UsdGeometry::UsdGeometry(const char* name, const char* type, UsdDevice* device)
: BridgedBaseObjectType(ANARI_GEOMETRY, name, device)
{
bool createTempArrays = false;
geomType = GetGeomType(type);
if(isInstanced() || geomType == GEOM_CURVE)
createTempArrays = true;
if(geomType == GEOM_UNKNOWN)
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' construction failed: type %s not supported", getName(), type);
if(createTempArrays)
tempArrays = std::make_unique<UsdGeometryTempArrays>(attributeArray);
}
UsdGeometry::~UsdGeometry()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
if(cachedBridge)
cachedBridge->DeleteGeometry(usdHandle);
#endif
}
void UsdGeometry::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteGeometry);
}
void UsdGeometry::filterSetParam(const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device)
{
if(geomType == GEOM_GLYPH && strEquals(name, "shapeType") || strEquals(name, "shapeGeometry") || strEquals(name, "shapeTransform"))
protoShapeChanged = true;
if(usdHandle.value && strEquals(name, "usd::useUsdGeomPoints"))
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_WARNING, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' filterSetParam failed: 'usd::useUsdGeomPoints' parameter cannot be changed after the first commit", getName());
return;
}
BridgedBaseObjectType::filterSetParam(name, type, mem, device);
}
template<typename GeomDataType>
void UsdGeometry::setAttributeTimeVarying(typename GeomDataType::DataMemberId& timeVarying)
{
typedef typename GeomDataType::DataMemberId DMI;
const UsdGeometryData& paramData = getReadParams();
static constexpr int attribStartBit = static_cast<int>(UsdGeometryComponents::ATTRIBUTE0);
for(size_t attribIdx = 0; attribIdx < attributeArray.size(); ++attribIdx)
{
DMI attributeId = DMI::ATTRIBUTE0 + attribIdx;
timeVarying = timeVarying &
(isBitSet(paramData.timeVarying, attribStartBit+(int)attribIdx) ? DMI::ALL : ~attributeId);
}
}
void UsdGeometry::syncAttributeArrays()
{
const UsdGeometryData& paramData = getReadParams();
// Find the max index of the last attribute that still contains an array
int attribCount = 0;
for(int i = 0; i < MAX_ATTRIBS; ++i)
{
if(paramData.primitiveAttributes[i] != nullptr || paramData.vertexAttributes[i] != nullptr)
attribCount = i+1;
}
// Set the attribute arrays and related info, resize temporary attribute array data for reordering
if(attribCount)
{
attributeArray.resize(attribCount);
for(int i = 0; i < attribCount; ++i)
{
const UsdDataArray* attribArray = paramData.vertexAttributes[i] ? paramData.vertexAttributes[i] : paramData.primitiveAttributes[i];
if (attribArray)
{
attributeArray[i].Data = attribArray->getData();
attributeArray[i].DataType = AnariToUsdBridgeType(attribArray->getType());
attributeArray[i].PerPrimData = paramData.vertexAttributes[i] ? false : true;
attributeArray[i].EltSize = static_cast<uint32_t>(anari::sizeOf(attribArray->getType()));
attributeArray[i].Name = UsdSharedString::c_str(paramData.attributeNames[i]);
}
else
{
attributeArray[i].Data = nullptr;
attributeArray[i].DataType = UsdBridgeType::UNDEFINED;
}
}
if(tempArrays)
tempArrays->AttributeDataArrays.resize(attribCount);
}
}
template<typename GeomDataType>
void UsdGeometry::copyAttributeArraysToData(GeomDataType& geomData)
{
geomData.Attributes = attributeArray.data();
geomData.NumAttributes = static_cast<uint32_t>(attributeArray.size());
}
void UsdGeometry::assignTempDataToAttributes(bool perPrimInterpolation)
{
const AttributeDataArraysType& attribDataArrays = tempArrays->AttributeDataArrays;
assert(attributeArray.size() == attribDataArrays.size());
for(size_t attribIdx = 0; attribIdx < attribDataArrays.size(); ++attribIdx)
{
if(attribDataArrays[attribIdx].size()) // Always > 0 if attributeArray[attribIdx].Data is set
attributeArray[attribIdx].Data = attribDataArrays[attribIdx].data();
attributeArray[attribIdx].PerPrimData = perPrimInterpolation; // Already converted to per-vertex (or per-prim)
}
}
void UsdGeometry::initializeGeomData(UsdBridgeMeshData& geomData)
{
typedef UsdBridgeMeshData::DataMemberId DMI;
const UsdGeometryData& paramData = getReadParams();
geomData.TimeVarying = DMI::ALL
& (isTimeVarying(CType::POSITION) ? DMI::ALL : ~DMI::POINTS)
& (isTimeVarying(CType::NORMAL) ? DMI::ALL : ~DMI::NORMALS)
& (isTimeVarying(CType::COLOR) ? DMI::ALL : ~DMI::COLORS)
& (isTimeVarying(CType::INDEX) ? DMI::ALL : ~DMI::INDICES);
setAttributeTimeVarying<UsdBridgeMeshData>(geomData.TimeVarying);
geomData.FaceVertexCount = geomType == GEOM_QUAD ? 4 : 3;
}
void UsdGeometry::initializeGeomData(UsdBridgeInstancerData& geomData)
{
typedef UsdBridgeInstancerData::DataMemberId DMI;
const UsdGeometryData& paramData = getReadParams();
geomData.TimeVarying = DMI::ALL
& (isTimeVarying(CType::POSITION) ? DMI::ALL : ~DMI::POINTS)
& (( ((geomType == GEOM_CYLINDER || geomType == GEOM_CONE)
&& (isTimeVarying(CType::NORMAL) || isTimeVarying(CType::POSITION) || isTimeVarying(CType::INDEX)))
|| ((geomType == GEOM_GLYPH) && isTimeVarying(CType::ORIENTATION))
) ? DMI::ALL : ~DMI::ORIENTATIONS)
& (isTimeVarying(CType::SCALE) ? DMI::ALL : ~DMI::SCALES)
& (isTimeVarying(CType::INDEX) ? DMI::ALL : ~DMI::INVISIBLEIDS)
& (isTimeVarying(CType::COLOR) ? DMI::ALL : ~DMI::COLORS)
& (isTimeVarying(CType::ID) ? DMI::ALL : ~DMI::INSTANCEIDS)
& ~DMI::SHAPEINDICES; // Shapeindices are always the same, and USD clients typically do not support timevarying shapes
setAttributeTimeVarying<UsdBridgeInstancerData>(geomData.TimeVarying);
geomData.UseUsdGeomPoints = geomType == GEOM_SPHERE && paramData.UseUsdGeomPoints;
}
void UsdGeometry::initializeGeomData(UsdBridgeCurveData& geomData)
{
typedef UsdBridgeCurveData::DataMemberId DMI;
const UsdGeometryData& paramData = getReadParams();
// Turn off what is not timeVarying
geomData.TimeVarying = DMI::ALL
& (isTimeVarying(CType::POSITION) ? DMI::ALL : ~DMI::POINTS)
& (isTimeVarying(CType::NORMAL) ? DMI::ALL : ~DMI::NORMALS)
& (isTimeVarying(CType::SCALE) ? DMI::ALL : ~DMI::SCALES)
& (isTimeVarying(CType::COLOR) ? DMI::ALL : ~DMI::COLORS)
& ((isTimeVarying(CType::POSITION) || isTimeVarying(CType::INDEX)) ? DMI::ALL : ~DMI::CURVELENGTHS);
setAttributeTimeVarying<UsdBridgeCurveData>(geomData.TimeVarying);
}
void UsdGeometry::initializeGeomRefData(UsdBridgeInstancerRefData& geomRefData)
{
const UsdGeometryData& paramData = getReadParams();
// The anari side currently only supports only one shape, so just set DefaultShape
bool isGlyph = geomType == GEOM_GLYPH;
if(isGlyph && paramData.shapeGeometry)
geomRefData.DefaultShape = UsdBridgeInstancerRefData::SHAPE_MESH;
else
{
UsdGeometry::GeomType defaultShape = (isGlyph && paramData.shapeType) ? GetGeomType(paramData.shapeType->c_str()) : geomType;
switch (defaultShape)
{
case GEOM_CYLINDER:
geomRefData.DefaultShape = UsdBridgeInstancerRefData::SHAPE_CYLINDER;
break;
case GEOM_CONE:
geomRefData.DefaultShape = UsdBridgeInstancerRefData::SHAPE_CONE;
break;
default:
geomRefData.DefaultShape = UsdBridgeInstancerRefData::SHAPE_SPHERE;
break;
};
}
geomRefData.ShapeTransform = paramData.shapeTransform;
}
bool UsdGeometry::checkArrayConstraints(const UsdDataArray* vertexArray, const UsdDataArray* primArray,
const char* paramName, UsdDevice* device, const char* debugName, int attribIndex)
{
const UsdGeometryData& paramData = getReadParams();
UsdLogInfo logInfo(device, this, ANARI_GEOMETRY, debugName);
const UsdDataArray* vertices = paramData.vertexPositions;
const UsdDataLayout& vertLayout = vertices->getLayout();
const UsdDataArray* indices = paramData.indices;
const UsdDataLayout& indexLayout = indices ? indices->getLayout() : vertLayout;
const UsdDataLayout& perVertLayout = vertexArray ? vertexArray->getLayout() : vertLayout;
const UsdDataLayout& perPrimLayout = primArray ? primArray->getLayout() : indexLayout;
const UsdDataLayout& attrLayout = vertexArray ? perVertLayout : perPrimLayout;
if (!AssertOneDimensional(attrLayout, logInfo, paramName)
|| !AssertNoStride(attrLayout, logInfo, paramName)
)
{
return false;
}
if (vertexArray && vertexArray->getLayout().numItems1 < vertLayout.numItems1)
{
if(attribIndex == -1)
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: all 'vertex.X' array elements should at least be the size of vertex.positions", debugName);
else
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: all 'vertex.attribute%i' array elements should at least be the size of vertex.positions", debugName, attribIndex);
return false;
}
uint64_t numPrims = GetNumberOfPrims(indices, indexLayout, geomType);
if (primArray && primArray->getLayout().numItems1 < numPrims)
{
if(attribIndex == -1)
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: size of 'primitive.X' array too small", debugName);
else
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: size of 'primitive.attribute%i' array too small", debugName, attribIndex);
return false;
}
return true;
}
bool UsdGeometry::checkGeomParams(UsdDevice* device)
{
const UsdGeometryData& paramData = getReadParams();
const char* debugName = getName();
bool success = true;
success = success && checkArrayConstraints(paramData.vertexPositions, nullptr, "vertex.position", device, debugName);
success = success && checkArrayConstraints(nullptr, paramData.indices, "primitive.index", device, debugName);
success = success && checkArrayConstraints(paramData.vertexNormals, paramData.primitiveNormals, "vertex/primitive.normal", device, debugName);
for(int i = 0; i < MAX_ATTRIBS; ++i)
success = success && checkArrayConstraints(paramData.vertexAttributes[i], paramData.primitiveAttributes[i], "vertex/primitive.attribute", device, debugName, i);
success = success && checkArrayConstraints(paramData.vertexColors, paramData.primitiveColors, "vertex/primitive.color", device, debugName);
success = success && checkArrayConstraints(paramData.vertexRadii, paramData.primitiveRadii, "vertex/primitive.radius", device, debugName);
success = success && checkArrayConstraints(paramData.vertexScales, paramData.primitiveScales, "vertex/primitive.scale", device, debugName);
success = success && checkArrayConstraints(paramData.vertexOrientations, paramData.primitiveOrientations, "vertex/primitive.orientation", device, debugName);
success = success && checkArrayConstraints(nullptr, paramData.primitiveIds, "primitive.id", device, debugName);
if (!success)
return false;
ANARIDataType vertType = paramData.vertexPositions->getType();
if (vertType != ANARI_FLOAT32_VEC3 && vertType != ANARI_FLOAT64_VEC3)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'vertex.position' parameter should be of type ANARI_FLOAT32_VEC3 or ANARI_FLOAT64_VEC3.", debugName);
return false;
}
if (paramData.indices)
{
ANARIDataType indexType = paramData.indices->getType();
UsdBridgeType flattenedType = AnariToUsdBridgeType_Flattened(indexType);
if( (geomType == GEOM_TRIANGLE || geomType == GEOM_QUAD) &&
(flattenedType == UsdBridgeType::UINT || flattenedType == UsdBridgeType::ULONG || flattenedType == UsdBridgeType::LONG))
{
static bool reported = false; // Hardcode this to show only once to make sure developers get to see it, without spamming the console.
if(!reported)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_WARNING, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' has 'primitive.index' of type other than ANARI_INT32, which may result in an overflow for FaceVertexIndicesAttr of UsdGeomMesh.", debugName);
reported = true;
}
}
if (geomType == GEOM_SPHERE || geomType == GEOM_CURVE || geomType == GEOM_GLYPH)
{
if(geomType == GEOM_SPHERE && paramData.UseUsdGeomPoints)
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_WARNING, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' is a sphere geometry with indices, but the usd::useUsdGeomPoints parameter is not set, so all vertices will show as spheres.", debugName);
if (indexType != ANARI_INT32 && indexType != ANARI_UINT32 && indexType != ANARI_INT64 && indexType != ANARI_UINT64)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'primitive.index' parameter should be of type ANARI_(U)INT32/64.", debugName);
return false;
}
}
else if (geomType == GEOM_CYLINDER || geomType == GEOM_CONE)
{
if (indexType != ANARI_UINT32_VEC2 && indexType != ANARI_INT32_VEC2 && indexType != ANARI_UINT64_VEC2 && indexType != ANARI_INT64_VEC2)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'primitive.index' parameter should be of type ANARI_(U)INT_VEC2.", debugName);
return false;
}
}
else if (geomType == GEOM_TRIANGLE)
{
if (indexType != ANARI_UINT32_VEC3 && indexType != ANARI_INT32_VEC3 && indexType != ANARI_UINT64_VEC3 && indexType != ANARI_INT64_VEC3)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'primitive.index' parameter should be of type ANARI_(U)INT_VEC3.", debugName);
return false;
}
}
else if (geomType == GEOM_QUAD)
{
if (indexType != ANARI_UINT32_VEC4 && indexType != ANARI_INT32_VEC4 && indexType != ANARI_UINT64_VEC4 && indexType != ANARI_INT64_VEC4)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'primitive.index' parameter should be of type ANARI_(U)INT_VEC4.", debugName);
return false;
}
}
}
const UsdDataArray* normals = paramData.vertexNormals ? paramData.vertexNormals : paramData.primitiveNormals;
if (normals)
{
ANARIDataType arrayType = normals->getType();
if (arrayType != ANARI_FLOAT32_VEC3 && arrayType != ANARI_FLOAT64_VEC3)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'vertex/primitive.normal' parameter should be of type ANARI_FLOAT32_VEC3 or ANARI_FLOAT64_VEC3.", debugName);
return false;
}
}
const UsdDataArray* colors = paramData.vertexColors ? paramData.vertexColors : paramData.primitiveColors;
if (colors)
{
ANARIDataType arrayType = colors->getType();
if ((int)arrayType < (int)ANARI_INT8 || (int)arrayType > (int)ANARI_UFIXED8_R_SRGB)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'vertex/primitive.color' parameter should be of Color type (see ANARI standard)", debugName);
return false;
}
}
const UsdDataArray* radii = paramData.vertexRadii ? paramData.vertexRadii : paramData.primitiveRadii;
if (radii)
{
ANARIDataType arrayType = radii->getType();
if (arrayType != ANARI_FLOAT32 && arrayType != ANARI_FLOAT64)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'vertex/primitive.radius' parameter should be of type ANARI_FLOAT32 or ANARI_FLOAT64.", debugName);
return false;
}
}
const UsdDataArray* scales = paramData.vertexScales ? paramData.vertexScales : paramData.primitiveScales;
if (scales)
{
ANARIDataType arrayType = scales->getType();
if (arrayType != ANARI_FLOAT32 && arrayType != ANARI_FLOAT64 && arrayType != ANARI_FLOAT32_VEC3 && arrayType != ANARI_FLOAT64_VEC3)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'vertex/primitive.scale' parameter should be of type ANARI_FLOAT32(_VEC3) or ANARI_FLOAT64(_VEC3).", debugName);
return false;
}
}
const UsdDataArray* orientations = paramData.vertexOrientations ? paramData.vertexOrientations : paramData.primitiveOrientations;
if (orientations)
{
ANARIDataType arrayType = orientations->getType();
if (arrayType != ANARI_FLOAT32_QUAT_IJKW)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'vertex/primitive.orientation' parameter should be of type ANARI_FLOAT32_QUAT_IJKW.", debugName);
return false;
}
}
if (paramData.primitiveIds)
{
ANARIDataType idType = paramData.primitiveIds->getType();
if (idType != ANARI_INT32 && idType != ANARI_UINT32 && idType != ANARI_INT64 && idType != ANARI_UINT64)
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: 'primitive.id' parameter should be of type ANARI_(U)INT or ANARI_(U)LONG.", debugName);
return false;
}
}
return true;
}
void UsdGeometry::updateGeomData(UsdDevice* device, UsdBridge* usdBridge, UsdBridgeMeshData& meshData, bool isNew)
{
const UsdGeometryData& paramData = getReadParams();
const UsdDataArray* vertices = paramData.vertexPositions;
meshData.NumPoints = vertices->getLayout().numItems1;
meshData.Points = vertices->getData();
meshData.PointsType = AnariToUsdBridgeType(vertices->getType());
const UsdDataArray* normals = paramData.vertexNormals ? paramData.vertexNormals : paramData.primitiveNormals;
if (normals)
{
meshData.Normals = normals->getData();
meshData.NormalsType = AnariToUsdBridgeType(normals->getType());
meshData.PerPrimNormals = paramData.vertexNormals ? false : true;
}
const UsdDataArray* colors = paramData.vertexColors ? paramData.vertexColors : paramData.primitiveColors;
if (colors)
{
meshData.Colors = colors->getData();
meshData.ColorsType = AnariToUsdBridgeType(colors->getType());
meshData.PerPrimColors = paramData.vertexColors ? false : true;
}
const UsdDataArray* indices = paramData.indices;
if (indices)
{
ANARIDataType indexType = indices->getType();
meshData.NumIndices = indices->getLayout().numItems1 * anari::componentsOf(indexType);
meshData.Indices = indices->getData();
meshData.IndicesType = AnariToUsdBridgeType_Flattened(indexType);
}
else
{
meshData.NumIndices = meshData.NumPoints; // Vertices are implicitly indexed consecutively (FaceVertexCount determines how many prims)
}
//meshData.UpdatesToPerform = Still to be implemented
double worldTimeStep = device->getReadParams().timeStep;
double dataTimeStep = selectObjTime(paramData.timeStep, worldTimeStep);
usdBridge->SetGeometryData(usdHandle, meshData, dataTimeStep);
}
void UsdGeometry::updateGeomData(UsdDevice* device, UsdBridge* usdBridge, UsdBridgeInstancerData& instancerData, bool isNew)
{
const UsdGeometryData& paramData = getReadParams();
const char* debugName = getName();
if (geomType == GEOM_SPHERE || geomType == GEOM_GLYPH)
{
// A paramData.indices (primitive-indexed spheres) array, is not supported in USD, also duplicate spheres make no sense.
// Instead, Ids/InvisibleIds are assigned to emulate sparsely indexed spheres (sourced from paramData.primitiveIds if available),
// with the per-vertex arrays remaining intact. Any per-prim arrays are explicitly converted to per-vertex via the tempArrays.
generateIndexedSphereData(paramData, attributeArray, tempArrays.get());
const UsdDataArray* vertices = paramData.vertexPositions;
instancerData.NumPoints = vertices->getLayout().numItems1;
instancerData.Points = vertices->getData();
instancerData.PointsType = AnariToUsdBridgeType(vertices->getType());
UsdGeometryDebugData dbgData = { device, this, debugName };
// Orientations
// are a bit extended beyond the spec: even spheres can set them, and the use of normals is also supported
if(paramData.vertexOrientations || paramData.primitiveOrientations)
{
setInstancerDataArray("orientation", paramData.vertexOrientations, paramData.primitiveOrientations, tempArrays->OrientationsArray, UsdBridgeType::FLOAT4,
instancerData.Orientations, instancerData.OrientationsType,
paramData, dbgData);
}
else
{
setInstancerDataArray("normal", paramData.vertexNormals, paramData.primitiveNormals, tempArrays->NormalsArray, UsdBridgeType::FLOAT3,
instancerData.Orientations, instancerData.OrientationsType,
paramData, dbgData);
}
// Scales
if(geomType == GEOM_SPHERE)
{
setInstancerDataArray("radius", paramData.vertexRadii, paramData.primitiveRadii,
tempArrays->RadiiArray, UsdBridgeType::FLOAT,
instancerData.Scales, instancerData.ScalesType,
paramData, dbgData);
}
else
{
size_t numTmpScales = tempArrays->ScalesArray.size();
bool scalarScale = (numTmpScales == instancerData.NumPoints);
assert(!numTmpScales || scalarScale || numTmpScales == instancerData.NumPoints*3);
setInstancerDataArray("scale", paramData.vertexScales, paramData.primitiveScales,
tempArrays->ScalesArray, scalarScale ? UsdBridgeType::FLOAT : UsdBridgeType::FLOAT3,
instancerData.Scales, instancerData.ScalesType,
paramData, dbgData);
}
// Colors
setInstancerDataArray("color", paramData.vertexColors, paramData.primitiveColors,
tempArrays->ColorsArray, AnariToUsdBridgeType(tempArrays->ColorsArrayType),
instancerData.Colors, instancerData.ColorsType,
paramData, dbgData);
// Attributes
// By default, syncAttributeArrays and initializeGeomData already set up instancerData.Attributes
// Just set attributeArray's data to tempArrays where necessary
if(paramData.indices)
{
// Type remains the same, everything per-vertex (as explained above)
assignTempDataToAttributes(false);
}
else
{
// Check whether any perprim attributes exist
for(size_t attribIdx = 0; attribIdx < attributeArray.size(); ++attribIdx)
{
if(attributeArray[attribIdx].Data && attributeArray[attribIdx].PerPrimData)
{
attributeArray[attribIdx].Data = nullptr;
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdGeometry '%s' primitive.attribute%i not transferred: per-primitive arrays provided without setting primitive.index", debugName, static_cast<int>(attribIdx));
}
}
}
// Ids
if (paramData.indices && tempArrays->IdsArray.size())
{
instancerData.InstanceIds = tempArrays->IdsArray.data();
instancerData.InstanceIdsType = UsdBridgeType::LONG;
}
else
{
const UsdDataArray* ids = paramData.primitiveIds;
if (ids)
{
instancerData.InstanceIds = ids->getData();
instancerData.InstanceIdsType = AnariToUsdBridgeType(ids->getType());
}
}
// Invisible Ids
if (paramData.indices && tempArrays->InvisIdsArray.size())
{
instancerData.InvisibleIds = tempArrays->InvisIdsArray.data();
instancerData.InvisibleIdsType = UsdBridgeType::LONG;
instancerData.NumInvisibleIds = tempArrays->InvisIdsArray.size();
}
for(int i = 0; i < 3; ++i)
instancerData.Scale.Data[i] = (geomType == GEOM_SPHERE) ? paramData.radiusConstant : paramData.scaleConstant.Data[i];
instancerData.Orientation = paramData.orientationConstant;
}
else
{
convertLinesToSticks(paramData, attributeArray, tempArrays.get());
instancerData.NumPoints = tempArrays->PointsArray.size()/3;
if (instancerData.NumPoints > 0)
{
instancerData.Points = tempArrays->PointsArray.data();
instancerData.PointsType = UsdBridgeType::FLOAT3;
instancerData.Scales = tempArrays->ScalesArray.data();
instancerData.ScalesType = UsdBridgeType::FLOAT3;
instancerData.Orientations = tempArrays->OrientationsArray.data();
instancerData.OrientationsType = UsdBridgeType::FLOAT4;
// Colors
if (tempArrays->ColorsArray.size())
{
instancerData.Colors = tempArrays->ColorsArray.data();
instancerData.ColorsType = AnariToUsdBridgeType(tempArrays->ColorsArrayType);
}
else if(const UsdDataArray* colors = paramData.primitiveColors)
{ // Per-primitive color array corresponds to per-vertex stick output
instancerData.Colors = colors->getData();
instancerData.ColorsType = AnariToUsdBridgeType(colors->getType());
}
// Attributes
assignTempDataToAttributes(false);
// Ids
if (tempArrays->IdsArray.size())
{
instancerData.InstanceIds = tempArrays->IdsArray.data();
instancerData.InstanceIdsType = UsdBridgeType::LONG;
}
}
}
double worldTimeStep = device->getReadParams().timeStep;
double dataTimeStep = selectObjTime(paramData.timeStep, worldTimeStep);
usdBridge->SetGeometryData(usdHandle, instancerData, dataTimeStep);
if(isNew && geomType != GEOM_GLYPH && !instancerData.UseUsdGeomPoints)
commitPrototypes(usdBridge); // Also initialize the prototype shape on the instancer geom
}
void UsdGeometry::updateGeomData(UsdDevice* device, UsdBridge* usdBridge, UsdBridgeCurveData& curveData, bool isNew)
{
const UsdGeometryData& paramData = getReadParams();
reorderCurveGeometry(paramData, attributeArray, tempArrays.get());
curveData.NumPoints = tempArrays->PointsArray.size() / 3;
if (curveData.NumPoints > 0)
{
curveData.Points = tempArrays->PointsArray.data();
curveData.PointsType = UsdBridgeType::FLOAT3;
curveData.CurveLengths = tempArrays->CurveLengths.data();
curveData.NumCurveLengths = tempArrays->CurveLengths.size();
if (tempArrays->NormalsArray.size())
{
curveData.Normals = tempArrays->NormalsArray.data();
curveData.NormalsType = UsdBridgeType::FLOAT3;
}
curveData.PerPrimNormals = false;// Always vertex colored as per reorderCurveGeometry. One entry per whole curve would be useless
// Attributes
assignTempDataToAttributes(false);
// Copy colors
if (tempArrays->ColorsArray.size())
{
curveData.Colors = tempArrays->ColorsArray.data();
curveData.ColorsType = AnariToUsdBridgeType(tempArrays->ColorsArrayType);
}
curveData.PerPrimColors = false; // Always vertex colored as per reorderCurveGeometry. One entry per whole curve would be useless
// Assign scales
if (tempArrays->ScalesArray.size())
{
curveData.Scales = tempArrays->ScalesArray.data();
curveData.ScalesType = UsdBridgeType::FLOAT;
}
curveData.UniformScale = paramData.radiusConstant;
}
double worldTimeStep = device->getReadParams().timeStep;
double dataTimeStep = selectObjTime(paramData.timeStep, worldTimeStep);
usdBridge->SetGeometryData(usdHandle, curveData, dataTimeStep);
}
template<typename UsdGeomType>
bool UsdGeometry::commitTemplate(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdGeometryData& paramData = getReadParams();
const char* debugName = getName();
UsdGeomType geomData;
syncAttributeArrays();
initializeGeomData(geomData);
copyAttributeArraysToData(geomData);
bool isNew = false;
if (!usdHandle.value)
{
isNew = usdBridge->CreateGeometry(debugName, usdHandle, geomData);
}
if (paramChanged || isNew)
{
if (paramData.vertexPositions)
{
if(checkGeomParams(device))
updateGeomData(device, usdBridge, geomData, isNew);
}
else
{
device->reportStatus(this, ANARI_GEOMETRY, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdGeometry '%s' commit failed: missing 'vertex.position'.", debugName);
}
paramChanged = false;
}
return isNew;
}
void UsdGeometry::commitPrototypes(UsdBridge* usdBridge)
{
UsdBridgeInstancerRefData instancerRefData;
initializeGeomRefData(instancerRefData);
usdBridge->SetPrototypeData(usdHandle, instancerRefData);
}
bool UsdGeometry::deferCommit(UsdDevice* device)
{
return false;
}
bool UsdGeometry::doCommitData(UsdDevice* device)
{
if(geomType == GEOM_UNKNOWN)
return false;
bool isNew = false;
switch (geomType)
{
case GEOM_TRIANGLE: isNew = commitTemplate<UsdBridgeMeshData>(device); break;
case GEOM_QUAD: isNew = commitTemplate<UsdBridgeMeshData>(device); break;
case GEOM_SPHERE: isNew = commitTemplate<UsdBridgeInstancerData>(device); break;
case GEOM_CYLINDER: isNew = commitTemplate<UsdBridgeInstancerData>(device); break;
case GEOM_CONE: isNew = commitTemplate<UsdBridgeInstancerData>(device); break;
case GEOM_GLYPH: isNew = commitTemplate<UsdBridgeInstancerData>(device); break;
case GEOM_CURVE: isNew = commitTemplate<UsdBridgeCurveData>(device); break;
default: break;
}
return geomType == GEOM_GLYPH && (isNew || protoShapeChanged); // Defer commit of prototypes until the geometry refs are in place
}
void UsdGeometry::doCommitRefs(UsdDevice* device)
{
assert(geomType == GEOM_GLYPH && protoShapeChanged);
UsdBridge* usdBridge = device->getUsdBridge();
const UsdGeometryData& paramData = getReadParams();
double worldTimeStep = device->getReadParams().timeStep;
// Make sure the references are updated on the Bridge side.
if (paramData.shapeGeometry)
{
double geomObjTimeStep = paramData.shapeGeometry->getReadParams().timeStep;
UsdGeometryHandle protoGeomHandle = paramData.shapeGeometry->getUsdHandle();
size_t numHandles = 1;
double protoTimestep = selectRefTime(paramData.shapeGeometryRefTimeStep, geomObjTimeStep, worldTimeStep);
usdBridge->SetPrototypeRefs(usdHandle,
&protoGeomHandle,
numHandles,
worldTimeStep,
&protoTimestep
);
}
else
{
usdBridge->DeletePrototypeRefs(usdHandle, worldTimeStep);
}
// Now set the prototype relations to the reference paths (Bridge uses paths from SetPrototypeRefs)
commitPrototypes(usdBridge);
protoShapeChanged = false;
}
| 56,898 | C++ | 38.431046 | 265 | 0.704049 |
NVIDIA-Omniverse/AnariUsdDevice/UsdGroup.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdGroup.h"
#include "UsdAnari.h"
#include "UsdDataArray.h"
#include "UsdDevice.h"
#include "UsdSurface.h"
#include "UsdVolume.h"
#define SurfaceType ANARI_SURFACE
#define VolumeType ANARI_VOLUME
using SurfaceUsdType = AnariToUsdBridgedObject<SurfaceType>::Type;
using VolumeUsdType = AnariToUsdBridgedObject<VolumeType>::Type;
DEFINE_PARAMETER_MAP(UsdGroup,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("surface", ANARI_ARRAY, surfaces)
REGISTER_PARAMETER_MACRO("volume", ANARI_ARRAY, volumes)
)
constexpr UsdGroup::ComponentPair UsdGroup::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
UsdGroup::UsdGroup(const char* name,
UsdDevice* device)
: BridgedBaseObjectType(ANARI_GROUP, name, device)
{
}
UsdGroup::~UsdGroup()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
if(cachedBridge)
cachedBridge->DeleteGroup(usdHandle);
#endif
}
void UsdGroup::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteGroup);
}
bool UsdGroup::deferCommit(UsdDevice* device)
{
const UsdGroupData& paramData = getReadParams();
if(UsdObjectNotInitialized<SurfaceUsdType>(paramData.surfaces) ||
UsdObjectNotInitialized<VolumeUsdType>(paramData.volumes))
{
return true;
}
return false;
}
bool UsdGroup::doCommitData(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
bool isNew = false;
if (!usdHandle.value)
isNew = usdBridge->CreateGroup(getName(), usdHandle);
if (paramChanged || isNew)
{
doCommitRefs(device); // Perform immediate commit of refs - no params from children required
paramChanged = false;
}
return false;
}
void UsdGroup::doCommitRefs(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdGroupData& paramData = getReadParams();
double timeStep = device->getReadParams().timeStep;
UsdLogInfo logInfo(device, this, ANARI_GROUP, this->getName());
bool surfacesTimeVarying = isTimeVarying(UsdGroupComponents::SURFACES);
bool volumesTimeVarying = isTimeVarying(UsdGroupComponents::VOLUMES);
ManageRefArray<SurfaceType, ANARISurface, UsdSurface>(usdHandle, paramData.surfaces, surfacesTimeVarying, timeStep,
surfaceHandles, &UsdBridge::SetSurfaceRefs, &UsdBridge::DeleteSurfaceRefs,
usdBridge, logInfo, "UsdGroup commit failed: 'surface' array elements should be of type ANARI_SURFACE");
ManageRefArray<VolumeType, ANARIVolume, UsdVolume>(usdHandle, paramData.volumes, volumesTimeVarying, timeStep,
volumeHandles, &UsdBridge::SetVolumeRefs, &UsdBridge::DeleteVolumeRefs,
usdBridge, logInfo, "UsdGroup commit failed: 'volume' array elements should be of type ANARI_VOLUME");
} | 2,925 | C++ | 30.462365 | 126 | 0.764103 |
NVIDIA-Omniverse/AnariUsdDevice/UsdFrame.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBaseObject.h"
#include "UsdParameterizedObject.h"
class UsdRenderer;
class UsdWorld;
struct UsdFrameData
{
UsdWorld* world = nullptr;
UsdRenderer* renderer = nullptr;
UsdUint2 size = {0, 0};
ANARIDataType color = ANARI_UNKNOWN;
ANARIDataType depth = ANARI_UNKNOWN;
};
class UsdFrame : public UsdParameterizedBaseObject<UsdFrame, UsdFrameData>
{
public:
UsdFrame(UsdBridge* bridge);
~UsdFrame();
void remove(UsdDevice* device) override {}
const void* mapBuffer(const char* channel,
uint32_t *width,
uint32_t *height,
ANARIDataType *pixelType);
void unmapBuffer(const char* channel);
void saveUsd(UsdDevice* device);
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override {}
char* ReserveBuffer(ANARIDataType format);
char* mappedColorMem = nullptr;
char* mappedDepthMem = nullptr;
};
| 1,070 | C | 21.787234 | 74 | 0.718692 |
NVIDIA-Omniverse/AnariUsdDevice/UsdCamera.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdCamera.h"
#include "UsdAnari.h"
#include "UsdDataArray.h"
#include "UsdDevice.h"
DEFINE_PARAMETER_MAP(UsdCamera,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("position", ANARI_FLOAT32_VEC3, position)
REGISTER_PARAMETER_MACRO("direction", ANARI_FLOAT32_VEC3, direction)
REGISTER_PARAMETER_MACRO("up", ANARI_FLOAT32_VEC3, up)
REGISTER_PARAMETER_MACRO("imageRegion", ANARI_FLOAT32_BOX2, imageRegion)
REGISTER_PARAMETER_MACRO("aspect", ANARI_FLOAT32, aspect)
REGISTER_PARAMETER_MACRO("near", ANARI_FLOAT32, near)
REGISTER_PARAMETER_MACRO("far", ANARI_FLOAT32, far)
REGISTER_PARAMETER_MACRO("fovy", ANARI_FLOAT32, fovy)
REGISTER_PARAMETER_MACRO("height", ANARI_FLOAT32, height)
)
constexpr UsdCamera::ComponentPair UsdCamera::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
UsdCamera::UsdCamera(const char* name, const char* type, UsdDevice* device)
: BridgedBaseObjectType(ANARI_CAMERA, name, device)
{
if(strEquals(type, "perspective"))
cameraType = CAMERA_PERSPECTIVE;
else if(strEquals(type, "orthographic"))
cameraType = CAMERA_ORTHOGRAPHIC;
}
UsdCamera::~UsdCamera()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
if(cachedBridge)
cachedBridge->DeleteGroup(usdHandle);
#endif
}
void UsdCamera::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteCamera);
}
bool UsdCamera::deferCommit(UsdDevice* device)
{
return false;
}
void UsdCamera::copyParameters(UsdBridgeCameraData& camData)
{
typedef UsdBridgeCameraData::DataMemberId DMI;
const UsdCameraData& paramData = getReadParams();
camData.Position = paramData.position;
camData.Direction = paramData.direction;
camData.Up = paramData.up;
camData.ImageRegion = paramData.imageRegion;
camData.Aspect = paramData.aspect;
camData.Near = paramData.near;
camData.Far = paramData.far;
camData.Fovy = paramData.fovy;
camData.Height = paramData.height;
camData.TimeVarying = DMI::ALL
& (isTimeVarying(CType::VIEW) ? DMI::ALL : ~DMI::VIEW)
& (isTimeVarying(CType::PROJECTION) ? DMI::ALL : ~DMI::PROJECTION);
}
bool UsdCamera::doCommitData(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdCameraData& paramData = getReadParams();
double timeStep = device->getReadParams().timeStep;
bool isNew = false;
if (!usdHandle.value)
isNew = usdBridge->CreateCamera(getName(), usdHandle);
if (paramChanged || isNew)
{
UsdBridgeCameraData camData;
copyParameters(camData);
usdBridge->SetCameraData(usdHandle, camData, timeStep);
paramChanged = false;
}
return false;
} | 2,864 | C++ | 29.478723 | 128 | 0.745461 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBaseObject.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "helium/utility/IntrusivePtr.h"
#include "UsdCommonMacros.h"
#include "UsdParameterizedObject.h"
class UsdDevice;
// Base parameterized class without being derived as such - nontemplated to allow for polymorphic use
class UsdBaseObject : public helium::RefCounted
{
public:
// If device != 0, the object is added to the commit list
UsdBaseObject(ANARIDataType t, UsdDevice* device = nullptr);
virtual void filterSetParam(
const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device) = 0;
virtual void filterResetParam(
const char *name) = 0;
virtual void resetAllParams() = 0;
virtual void* getParameter(const char* name, ANARIDataType& returnType) = 0;
virtual int getProperty(const char *name,
ANARIDataType type,
void *mem,
uint64_t size,
UsdDevice* device) = 0;
virtual void commit(UsdDevice* device) = 0;
virtual void remove(UsdDevice* device) = 0; // Remove any committed data and refs
ANARIDataType getType() const { return type; }
protected:
virtual bool deferCommit(UsdDevice* device) = 0; // Returns whether data commit has to be deferred
virtual bool doCommitData(UsdDevice* device) = 0; // Data commit, execution can be immediate, returns whether doCommitRefs has to be performed
virtual void doCommitRefs(UsdDevice* device) = 0; // For updates with dependencies on referenced object's data, is always executed deferred
ANARIDataType type;
friend class UsdDevice;
};
// Templated base implementation of parameterized object
template<typename T, typename D>
class UsdParameterizedBaseObject : public UsdBaseObject, public UsdParameterizedObject<T, D>
{
public:
typedef UsdParameterizedObject<T, D> ParamClass;
UsdParameterizedBaseObject(ANARIDataType t, UsdDevice* device = nullptr)
: UsdBaseObject(t, device)
{}
void filterSetParam(
const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device) override
{
ParamClass::setParam(name, type, mem, device);
}
void filterResetParam(
const char *name) override
{
ParamClass::resetParam(name);
}
void resetAllParams() override
{
ParamClass::resetParams();
}
void* getParameter(const char* name, ANARIDataType& returnType) override
{
return ParamClass::getParam(name, returnType);
}
int getProperty(const char *name,
ANARIDataType type,
void *mem,
uint64_t size,
UsdDevice* device) override
{
return 0;
}
void commit(UsdDevice* device) override
{
ParamClass::transferWriteToReadParams();
UsdBaseObject::commit(device);
}
// Convenience functions for commonly used name property
virtual const char* getName() const { return ""; }
protected:
// Convenience functions for commonly used name property
bool setNameParam(const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device)
{
const char* objectName = static_cast<const char*>(mem);
if (type == ANARI_STRING)
{
if (strEquals(name, "name"))
{
if (!objectName || strEquals(objectName, ""))
{
reportStatusThroughDevice(UsdLogInfo(device, this, ANARI_OBJECT, nullptr), ANARI_SEVERITY_WARNING, ANARI_STATUS_NO_ERROR,
"%s: ANARI object %s cannot be an empty string, using auto-generated name instead.", getName(), "name");
}
else
{
ParamClass::setParam(name, type, mem, device);
ParamClass::setParam("usd::name", type, mem, device);
this->formatUsdName(this->getWriteParams().usdName);
}
return true;
}
else if (strEquals(name, "usd::name"))
{
reportStatusThroughDevice(UsdLogInfo(device, this, ANARI_OBJECT, nullptr), ANARI_SEVERITY_WARNING, ANARI_STATUS_NO_ERROR,
"%s parameter '%s' cannot be set, only read with getProperty().", getName(), "usd::name");
return true;
}
}
return false;
}
int getNameProperty(const char *name,
ANARIDataType type,
void *mem,
uint64_t size,
UsdDevice* device)
{
if (type == ANARI_STRING && strEquals(name, "usd::name"))
{
snprintf((char*)mem, size, "%s", UsdSharedString::c_str(this->getReadParams().usdName));
return 1;
}
else if (type == ANARI_UINT64 && strEquals(name, "usd::name.size"))
{
if (Assert64bitStringLengthProperty(size, UsdLogInfo(device, this, ANARI_ARRAY, this->getName()), "usd::name.size"))
{
uint64_t nameLen = this->getReadParams().usdName ? strlen(this->getReadParams().usdName->c_str())+1 : 0;
memcpy(mem, &nameLen, size);
}
return 1;
}
return 0;
}
}; | 5,007 | C | 29.168675 | 146 | 0.641901 |
NVIDIA-Omniverse/AnariUsdDevice/UsdAnari.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgeData.h"
#include "UsdCommonMacros.h"
#include "anari/frontend/anari_enums.h"
#include "anari/anari_cpp/Traits.h"
#include <cstring>
class UsdDevice;
class UsdDataArray;
class UsdFrame;
class UsdGeometry;
class UsdGroup;
class UsdInstance;
class UsdLight;
class UsdMaterial;
class UsdRenderer;
class UsdSurface;
class UsdSampler;
class UsdSpatialField;
class UsdVolume;
class UsdWorld;
class UsdCamera;
class UsdSharedString;
class UsdBaseObject;
struct UsdDataLayout;
namespace anari
{
ANARI_TYPEFOR_SPECIALIZATION(UsdUint2, ANARI_UINT32_VEC2);
ANARI_TYPEFOR_SPECIALIZATION(UsdFloat2, ANARI_FLOAT32_VEC2);
ANARI_TYPEFOR_SPECIALIZATION(UsdFloat3, ANARI_FLOAT32_VEC3);
ANARI_TYPEFOR_SPECIALIZATION(UsdFloat4, ANARI_FLOAT32_VEC4);
ANARI_TYPEFOR_SPECIALIZATION(UsdQuaternion, ANARI_FLOAT32_QUAT_IJKW);
ANARI_TYPEFOR_SPECIALIZATION(UsdFloatMat4, ANARI_FLOAT32_MAT4);
ANARI_TYPEFOR_SPECIALIZATION(UsdFloatBox1, ANARI_FLOAT32_BOX1);
ANARI_TYPEFOR_SPECIALIZATION(UsdFloatBox2, ANARI_FLOAT32_BOX2);
ANARI_TYPEFOR_SPECIALIZATION(UsdSharedString*, ANARI_STRING);
ANARI_TYPEFOR_SPECIALIZATION(UsdDataArray*, ANARI_ARRAY);
ANARI_TYPEFOR_SPECIALIZATION(UsdFrame*, ANARI_FRAME);
ANARI_TYPEFOR_SPECIALIZATION(UsdGeometry*, ANARI_GEOMETRY);
ANARI_TYPEFOR_SPECIALIZATION(UsdGroup*, ANARI_GROUP);
ANARI_TYPEFOR_SPECIALIZATION(UsdInstance*, ANARI_INSTANCE);
ANARI_TYPEFOR_SPECIALIZATION(UsdLight*, ANARI_LIGHT);
ANARI_TYPEFOR_SPECIALIZATION(UsdMaterial*, ANARI_MATERIAL);
ANARI_TYPEFOR_SPECIALIZATION(UsdRenderer*, ANARI_RENDERER);
ANARI_TYPEFOR_SPECIALIZATION(UsdSampler*, ANARI_SAMPLER);
ANARI_TYPEFOR_SPECIALIZATION(UsdSpatialField*, ANARI_SPATIAL_FIELD);
ANARI_TYPEFOR_SPECIALIZATION(UsdSurface*, ANARI_SURFACE);
ANARI_TYPEFOR_SPECIALIZATION(UsdVolume*, ANARI_VOLUME);
ANARI_TYPEFOR_SPECIALIZATION(UsdWorld*, ANARI_WORLD);
}
// Shared convenience functions
namespace
{
inline bool strEquals(const char* arg0, const char* arg1)
{
return strcmp(arg0, arg1) == 0;
}
template <typename T>
inline void writeToVoidP(void *_p, T v)
{
T *p = (T *)_p;
*p = v;
}
}
// Standard log info
struct UsdLogInfo
{
UsdLogInfo(UsdDevice* dev, void* src, ANARIDataType srcType, const char* srcName)
: device(dev)
, source(src)
, sourceType(srcType)
, sourceName(srcName)
{}
UsdDevice* device = nullptr;
void* source = nullptr;
ANARIDataType sourceType = ANARI_VOID_POINTER;
const char* sourceName = nullptr;
};
void reportStatusThroughDevice(const UsdLogInfo& logInfo, ANARIStatusSeverity severity, ANARIStatusCode statusCode,
const char *format, const char* firstArg, const char* secondArg); // In case #include <UsdDevice.h> is undesired
#ifdef CHECK_MEMLEAKS
void logAllocationThroughDevice(UsdDevice* device, const void* ptr, ANARIDataType ptrType);
void logDeallocationThroughDevice(UsdDevice* device, const void* ptr, ANARIDataType ptrType);
#endif
// Anari <=> USD conversions
UsdBridgeType AnariToUsdBridgeType(ANARIDataType anariType);
UsdBridgeType AnariToUsdBridgeType_Flattened(ANARIDataType anariType);
const char* AnariTypeToString(ANARIDataType anariType);
const char* AnariAttributeToUsdName(const char* param, bool perInstance, const UsdLogInfo& logInfo);
UsdBridgeMaterialData::AlphaModes AnariToUsdAlphaMode(const char* alphaMode);
ANARIStatusSeverity UsdBridgeLogLevelToAnariSeverity(UsdBridgeLogLevel level);
bool Assert64bitStringLengthProperty(uint64_t size, const UsdLogInfo& logInfo, const char* propName);
bool AssertOneDimensional(const UsdDataLayout& layout, const UsdLogInfo& logInfo, const char* arrayName);
bool AssertNoStride(const UsdDataLayout& layout, const UsdLogInfo& logInfo, const char* arrayName);
bool AssertArrayType(UsdDataArray* dataArray, ANARIDataType dataType, const UsdLogInfo& logInfo, const char* errorMessage);
// Template definitions
template<typename AnariType>
class AnariToUsdObject {};
template<int AnariType>
class AnariToUsdBridgedObject {};
template<int AnariType>
class AnariToUsdBaseObject {};
#define USDBRIDGE_DEFINE_OBJECT_MAPPING(AnariType, UsdType) \
template<>\
class AnariToUsdObject<AnariType>\
{\
public:\
using Type = UsdType;\
};
#define USDBRIDGE_DEFINE_BASE_OBJECT_MAPPING(AnariType, UsdType) \
template<>\
class AnariToUsdBaseObject<(int)AnariType>\
{\
public:\
using Type = UsdType;\
};
#define USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(AnariType, UsdType)\
template<>\
class AnariToUsdBridgedObject<(int)AnariType>\
{\
public:\
using Type = UsdType;\
};\
template<>\
class AnariToUsdBaseObject<(int)AnariType>\
{\
public:\
using Type = UsdType;\
};
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIObject, UsdBaseObject)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIDevice, UsdDevice)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIArray, UsdDataArray)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIArray1D, UsdDataArray)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIArray2D, UsdDataArray)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIArray3D, UsdDataArray)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIFrame, UsdFrame)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIGeometry, UsdGeometry)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIGroup, UsdGroup)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIInstance, UsdInstance)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARILight, UsdLight)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIMaterial, UsdMaterial)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARISampler, UsdSampler)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARISurface, UsdSurface)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIRenderer, UsdRenderer)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARISpatialField, UsdSpatialField)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIVolume, UsdVolume)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARIWorld, UsdWorld)
USDBRIDGE_DEFINE_OBJECT_MAPPING(ANARICamera, UsdCamera)
USDBRIDGE_DEFINE_BASE_OBJECT_MAPPING(ANARI_DEVICE, UsdDevice)
USDBRIDGE_DEFINE_BASE_OBJECT_MAPPING(ANARI_ARRAY, UsdDataArray)
USDBRIDGE_DEFINE_BASE_OBJECT_MAPPING(ANARI_ARRAY1D, UsdDataArray)
USDBRIDGE_DEFINE_BASE_OBJECT_MAPPING(ANARI_ARRAY2D, UsdDataArray)
USDBRIDGE_DEFINE_BASE_OBJECT_MAPPING(ANARI_ARRAY3D, UsdDataArray)
USDBRIDGE_DEFINE_BASE_OBJECT_MAPPING(ANARI_FRAME, UsdFrame)
USDBRIDGE_DEFINE_BASE_OBJECT_MAPPING(ANARI_RENDERER, UsdRenderer)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_GEOMETRY, UsdGeometry)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_GROUP, UsdGroup)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_INSTANCE, UsdInstance)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_LIGHT, UsdLight)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_MATERIAL, UsdMaterial)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_SURFACE, UsdSurface)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_SAMPLER, UsdSampler)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_SPATIAL_FIELD, UsdSpatialField)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_VOLUME, UsdVolume)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_WORLD, UsdWorld)
USDBRIDGE_DEFINE_BRIDGED_OBJECT_MAPPING(ANARI_CAMERA, UsdCamera)
template<typename AnariType>
typename AnariToUsdObject<AnariType>::Type* AnariToUsdObjectPtr(AnariType object) { return (typename AnariToUsdObject<AnariType>::Type*) object; }
| 7,214 | C | 36.38342 | 146 | 0.804963 |
NVIDIA-Omniverse/AnariUsdDevice/UsdWorld.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdWorld.h"
#include "UsdAnari.h"
#include "UsdInstance.h"
#include "UsdSurface.h"
#include "UsdVolume.h"
#include "UsdDevice.h"
#include "UsdDataArray.h"
#include "UsdGroup.h"
#define InstanceType ANARI_INSTANCE
#define SurfaceType ANARI_SURFACE
#define VolumeType ANARI_VOLUME
using InstanceUsdType = AnariToUsdBridgedObject<InstanceType>::Type;
using SurfaceUsdType = AnariToUsdBridgedObject<SurfaceType>::Type;
using VolumeUsdType = AnariToUsdBridgedObject<VolumeType>::Type;
DEFINE_PARAMETER_MAP(UsdWorld,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("instance", ANARI_ARRAY, instances)
REGISTER_PARAMETER_MACRO("surface", ANARI_ARRAY, surfaces)
REGISTER_PARAMETER_MACRO("volume", ANARI_ARRAY, volumes)
)
constexpr UsdWorld::ComponentPair UsdWorld::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
UsdWorld::UsdWorld(const char* name, UsdDevice* device)
: BridgedBaseObjectType(ANARI_WORLD, name, device)
{
}
UsdWorld::~UsdWorld()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
if(cachedBridge)
cachedBridge->DeleteWorld(usdHandle);
#endif
}
void UsdWorld::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteWorld);
}
bool UsdWorld::deferCommit(UsdDevice* device)
{
const UsdWorldData& paramData = getReadParams();
if(UsdObjectNotInitialized<InstanceUsdType>(paramData.instances) ||
UsdObjectNotInitialized<SurfaceUsdType>(paramData.surfaces) ||
UsdObjectNotInitialized<VolumeUsdType>(paramData.volumes))
{
return true;
}
return false;
}
bool UsdWorld::doCommitData(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const char* objName = getName();
bool isNew = false;
if(!usdHandle.value)
isNew = usdBridge->CreateWorld(objName, usdHandle);
if (paramChanged || isNew)
{
doCommitRefs(device); // Perform immediate commit of refs - no params from children required
paramChanged = false;
}
return false;
}
void UsdWorld::doCommitRefs(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdWorldData& paramData = getReadParams();
double timeStep = device->getReadParams().timeStep;
const char* objName = getName();
bool instancesTimeVarying = isTimeVarying(UsdWorldComponents::INSTANCES);
bool surfacesTimeVarying = isTimeVarying(UsdWorldComponents::SURFACES);
bool volumesTimeVarying = isTimeVarying(UsdWorldComponents::VOLUMES);
UsdLogInfo logInfo(device, this, ANARI_WORLD, this->getName());
ManageRefArray<InstanceType, ANARIInstance, UsdInstance>(usdHandle, paramData.instances, instancesTimeVarying, timeStep,
instanceHandles, &UsdBridge::SetInstanceRefs, &UsdBridge::DeleteInstanceRefs,
usdBridge, logInfo, "UsdWorld commit failed: 'instance' array elements should be of type ANARI_INSTANCE");
ManageRefArray<SurfaceType, ANARISurface, UsdSurface>(usdHandle, paramData.surfaces, surfacesTimeVarying, timeStep,
surfaceHandles, &UsdBridge::SetSurfaceRefs, &UsdBridge::DeleteSurfaceRefs,
usdBridge, logInfo, "UsdGroup commit failed: 'surface' array elements should be of type ANARI_SURFACE");
ManageRefArray<VolumeType, ANARIVolume, UsdVolume>(usdHandle, paramData.volumes, volumesTimeVarying, timeStep,
volumeHandles, &UsdBridge::SetVolumeRefs, &UsdBridge::DeleteVolumeRefs,
usdBridge, logInfo, "UsdGroup commit failed: 'volume' array elements should be of type ANARI_VOLUME");
} | 3,668 | C++ | 33.289719 | 126 | 0.771538 |
NVIDIA-Omniverse/AnariUsdDevice/UsdSurface.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdSurface.h"
#include "UsdAnari.h"
#include "UsdDevice.h"
#include "UsdMaterial.h"
#include "UsdGeometry.h"
#define GeometryType ANARI_GEOMETRY
#define MaterialType ANARI_MATERIAL
using GeometryUsdType = AnariToUsdBridgedObject<GeometryType>::Type;
using MaterialUsdType = AnariToUsdBridgedObject<MaterialType>::Type;
DEFINE_PARAMETER_MAP(UsdSurface,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::time.geometry", ANARI_FLOAT64, geometryRefTimeStep)
REGISTER_PARAMETER_MACRO("usd::time.material", ANARI_FLOAT64, materialRefTimeStep)
REGISTER_PARAMETER_MACRO("geometry", GeometryType, geometry)
REGISTER_PARAMETER_MACRO("material", MaterialType, material)
)
UsdSurface::UsdSurface(const char* name, UsdDevice* device)
: BridgedBaseObjectType(ANARI_SURFACE, name, device)
{
}
UsdSurface::~UsdSurface()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
// Given that the object is destroyed, none of its references to other objects
// has to be updated anymore.
if(cachedBridge)
cachedBridge->DeleteSurface(usdHandle);
#endif
}
void UsdSurface::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteSurface);
}
bool UsdSurface::deferCommit(UsdDevice* device)
{
// Given that all handles/data are used in doCommitRefs, which is always executed deferred, we don't need to check for initialization
//const UsdSurfaceData& paramData = getReadParams();
//if(UsdObjectNotInitialized<GeometryUsdType>(paramData.geometry) || UsdObjectNotInitialized<MaterialUsdType>(paramData.material))
//{
// return true;
//}
return false;
}
bool UsdSurface::doCommitData(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
bool isNew = false;
if (!usdHandle.value)
isNew = usdBridge->CreateSurface(getName(), usdHandle);
if (paramChanged || isNew)
{
paramChanged = false;
return true; // In this case a doCommitRefs is required, with data (timesteps, handles) from children
}
return false;
}
void UsdSurface::doCommitRefs(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdSurfaceData& paramData = getReadParams();
double worldTimeStep = device->getReadParams().timeStep;
// Make sure the references are updated on the Bridge side.
if (paramData.geometry)
{
double geomObjTimeStep = paramData.geometry->getReadParams().timeStep;
if(device->getReadParams().outputMaterial && paramData.material)
{
double matObjTimeStep = paramData.material->getReadParams().timeStep;
// The geometry to which a material binds has an effect on attribute reader (geom primvar) names, and output types
paramData.material->updateBoundParameters(paramData.geometry->isInstanced(), device);
usdBridge->SetGeometryMaterialRef(usdHandle,
paramData.geometry->getUsdHandle(),
paramData.material->getUsdHandle(),
worldTimeStep,
selectRefTime(paramData.geometryRefTimeStep, geomObjTimeStep, worldTimeStep),
selectRefTime(paramData.materialRefTimeStep, matObjTimeStep, worldTimeStep)
);
}
else
{
usdBridge->SetGeometryRef(usdHandle,
paramData.geometry->getUsdHandle(),
worldTimeStep,
selectRefTime(paramData.geometryRefTimeStep, geomObjTimeStep, worldTimeStep)
);
usdBridge->DeleteMaterialRef(usdHandle, worldTimeStep);
}
}
else
{
usdBridge->DeleteGeometryRef(usdHandle, worldTimeStep);
if (!paramData.material && device->getReadParams().outputMaterial)
{
usdBridge->DeleteMaterialRef(usdHandle, worldTimeStep);
}
}
} | 3,776 | C++ | 30.475 | 135 | 0.739142 |
NVIDIA-Omniverse/AnariUsdDevice/UsdCommonMacros.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridge/Common/UsdBridgeMacros.h"
//#define OBJECT_LIFETIME_EQUALS_USD_LIFETIME
#ifndef NDEBUG
// This is now handled in CMake
//#define CHECK_MEMLEAKS //asserts at ~UsdDevice() if memleak found
#endif
| 306 | C | 20.92857 | 67 | 0.761438 |
NVIDIA-Omniverse/AnariUsdDevice/UsdVolume.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdVolume.h"
#include "UsdAnari.h"
#include "UsdDevice.h"
#include "UsdSpatialField.h"
#include "UsdDataArray.h"
DEFINE_PARAMETER_MAP(UsdVolume,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("usd::preClassified", ANARI_BOOL, preClassified)
REGISTER_PARAMETER_MACRO("usd::time.value", ANARI_FLOAT64, fieldRefTimeStep)
REGISTER_PARAMETER_MACRO("value", ANARI_SPATIAL_FIELD, field)
REGISTER_PARAMETER_MACRO("color", ANARI_ARRAY, color)
REGISTER_PARAMETER_MACRO("opacity", ANARI_ARRAY, opacity)
REGISTER_PARAMETER_MACRO("valueRange", ANARI_FLOAT32_BOX1, valueRange)
REGISTER_PARAMETER_MACRO("unitDistance", ANARI_FLOAT32, unitDistance)
)
constexpr UsdVolume::ComponentPair UsdVolume::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
namespace
{
void GatherTfData(const UsdVolumeData& paramData, UsdBridgeTfData& tfData)
{
// Get transfer function data
const UsdDataArray* tfColor = paramData.color;
const UsdDataArray* tfOpacity = paramData.opacity;
UsdBridgeType tfColorType = AnariToUsdBridgeType(tfColor->getType());
UsdBridgeType tfOpacityType = AnariToUsdBridgeType(tfOpacity->getType());
// Write to struct
tfData.TfColors = tfColor->getData();
tfData.TfColorsType = tfColorType;
tfData.TfNumColors = (int)(tfColor->getLayout().numItems1);
tfData.TfOpacities = tfOpacity->getData();
tfData.TfOpacitiesType = tfOpacityType;
tfData.TfNumOpacities = (int)(tfOpacity->getLayout().numItems1);
tfData.TfValueRange[0] = paramData.valueRange.Data[0];
tfData.TfValueRange[1] = paramData.valueRange.Data[1];
}
}
UsdVolume::UsdVolume(const char* name, UsdDevice* device)
: BridgedBaseObjectType(ANARI_VOLUME, name, device)
, usdDevice(device)
{
usdDevice->addToVolumeList(this);
}
UsdVolume::~UsdVolume()
{
usdDevice->removeFromVolumeList(this);
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
// Given that the object is destroyed, none of its references to other objects
// has to be updated anymore.
if(cachedBridge)
cachedBridge->DeleteVolume(usdHandle);
#endif
}
void UsdVolume::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteVolume);
}
bool UsdVolume::CheckTfParams(UsdDevice* device)
{
const UsdVolumeData& paramData = getReadParams();
const char* debugName = getName();
UsdLogInfo logInfo(device, this, ANARI_VOLUME, debugName);
// Only perform data(type) checks, data upload along with field in UsdVolume::commit()
const UsdDataArray* tfColor = paramData.color;
if (paramData.color == nullptr)
{
device->reportStatus(this, ANARI_VOLUME, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdVolume '%s' commit failed: transferfunction color array not set.", debugName);
return false;
}
const UsdDataArray* tfOpacity = paramData.opacity;
if (tfOpacity == nullptr)
{
device->reportStatus(this, ANARI_VOLUME, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdVolume '%s' commit failed: transferfunction opacity not set.", debugName);
return false;
}
if (!AssertOneDimensional(tfColor->getLayout(), logInfo, "tfColor"))
{
device->reportStatus(this, ANARI_VOLUME, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdVolume '%s' commit failed: transferfunction color array not one-dimensional.", debugName);
return false;
}
if (!AssertOneDimensional(tfOpacity->getLayout(), logInfo, "tfOpacity"))
{
device->reportStatus(this, ANARI_VOLUME, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdVolume '%s' commit failed: transferfunction opacity array not one-dimensional.", debugName);
return false;
}
if (paramData.preClassified && tfColor->getType() != ANARI_FLOAT32_VEC3)
{
device->reportStatus(this, ANARI_VOLUME, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdVolume '%s' commit failed: transferfunction color array needs to be of type ANARI_FLOAT32_VEC3 when preClassified is set.", debugName);
return false;
}
if (tfOpacity->getType() != ANARI_FLOAT32)
{
device->reportStatus(this, ANARI_VOLUME, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdVolume '%s' commit failed: transferfunction opacity array needs to be of type ANARI_FLOAT32.", debugName);
return false;
}
if (tfColor->getLayout().numItems1 != tfOpacity->getLayout().numItems1)
{
device->reportStatus(this, ANARI_VOLUME, ANARI_SEVERITY_WARNING, ANARI_STATUS_INVALID_ARGUMENT,
"UsdVolume '%s' commit warning: transferfunction output merges colors and opacities into one array, so they should contain the same number of elements.", debugName);
}
return true;
}
bool UsdVolume::UpdateVolume(UsdDevice* device, const char* debugName)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdVolumeData& paramData = getReadParams();
UsdSpatialField* field = paramData.field;
if (!CheckTfParams(device))
return false;
// Get field data
const UsdSpatialFieldData& fieldParams = field->getReadParams();
const UsdDataArray* fieldDataArray = fieldParams.data;
if(!fieldDataArray) return false; // Enforced in field commit()
const UsdDataLayout& posLayout = fieldDataArray->getLayout();
UsdBridgeType fieldDataType = AnariToUsdBridgeType(fieldDataArray->getType());
//Set bridge volumedata
UsdBridgeVolumeData volumeData;
volumeData.Data = fieldDataArray->getData();
volumeData.DataType = fieldDataType;
size_t* elts = volumeData.NumElements;
float* ori = volumeData.Origin;
float* celldims = volumeData.CellDimensions;
elts[0] = posLayout.numItems1; elts[1] = posLayout.numItems2; elts[2] = posLayout.numItems3;
ori[0] = fieldParams.gridOrigin[0]; ori[1] = fieldParams.gridOrigin[1]; ori[2] = fieldParams.gridOrigin[2];
celldims[0] = fieldParams.gridSpacing[0]; celldims[1] = fieldParams.gridSpacing[1]; celldims[2] = fieldParams.gridSpacing[2];
GatherTfData(paramData, volumeData.TfData);
// Set whether we want to output source data or preclassified colored volumes
volumeData.preClassified = paramData.preClassified;
typedef UsdBridgeVolumeData::DataMemberId DMI;
volumeData.TimeVarying = DMI::ALL
& (field->isTimeVarying(UsdSpatialFieldComponents::DATA) ? DMI::ALL : ~DMI::DATA)
& (isTimeVarying(CType::COLOR) ? DMI::ALL : ~DMI::TFCOLORS)
& (isTimeVarying(CType::OPACITY) ? DMI::ALL : ~DMI::TFOPACITIES)
& (isTimeVarying(CType::VALUERANGE) ? DMI::ALL : ~DMI::TFVALUERANGE);
double worldTimeStep = device->getReadParams().timeStep;
double fieldTimeStep = selectRefTime(paramData.fieldRefTimeStep, fieldParams.timeStep, worldTimeStep); // use the link time, as there is no such thing as separate field data
usdBridge->SetSpatialFieldData(field->getUsdHandle(), volumeData, fieldTimeStep);
return true;
}
bool UsdVolume::deferCommit(UsdDevice* device)
{
// The spatial field may not yet have been committed, but the volume reads data from its params during commit. So always defer until flushing of commit list.
return !device->isFlushingCommitList();
}
bool UsdVolume::doCommitData(UsdDevice* device)
{
const UsdVolumeData& paramData = getReadParams();
UsdBridge* usdBridge = device->getUsdBridge();
bool isNew = false;
if (!usdHandle.value)
isNew = usdBridge->CreateVolume(getName(), usdHandle);
const char* debugName = getName();
if (prevField != paramData.field)
{
double worldTimeStep = device->getReadParams().timeStep;
// Make sure the references are updated on the Bridge side.
if (paramData.field)
{
const UsdSpatialFieldData& fieldParams = paramData.field->getReadParams();
usdBridge->SetSpatialFieldRef(usdHandle,
paramData.field->getUsdHandle(),
worldTimeStep,
selectRefTime(paramData.fieldRefTimeStep, fieldParams.timeStep, worldTimeStep)
);
}
else
{
usdBridge->DeleteSpatialFieldRef(usdHandle, worldTimeStep);
}
prevField = paramData.field;
}
// Regardless of whether tf param changes, field params or the vol reference itself, UpdateVolume is required.
if (paramChanged || paramData.field->paramChanged)
{
if(paramData.field)
{
UpdateVolume(device, debugName);
paramChanged = false;
paramData.field->paramChanged = false;
}
else
{
device->reportStatus(this, ANARI_VOLUME, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdVolume '%s' commit failed: field reference missing.", debugName);
}
}
return false;
} | 8,778 | C++ | 35.127572 | 175 | 0.733424 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridgedBaseObject.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBaseObject.h"
#include "UsdBridge/UsdBridge.h"
#include "UsdDevice.h"
#include "UsdDataArray.h"
#include <cmath>
#include <utility>
enum class UsdEmptyComponents
{
};
template<typename T, typename D, typename H, typename C = UsdEmptyComponents>
class UsdBridgedBaseObject : public UsdParameterizedBaseObject<T, D>
{
protected:
using CType = C;
// Timevarying helper functions (classes workaround to allow for partial specialization)
template<typename IT, typename ID, typename IH, typename IC>
class TimeVaryingClass
{
public:
bool findTimeVarying(const char* name, IC& component)
{
for(auto& cmpName : IT::componentParamNames)
{
if(strEquals(name, cmpName.second))
{
component = cmpName.first;
return true;
}
}
return false;
}
void setTimeVarying(UsdBridgedBaseObject<IT,ID,IH,IC>* bridgedObj, IC component, bool value)
{
ID& params = bridgedObj->getWriteParams();
int bit = (1 << static_cast<int>(component));
params.timeVarying = value ? (params.timeVarying | bit) : (params.timeVarying & ~bit);
}
};
template<typename IT, typename ID, typename IH>
class TimeVaryingClass<IT, ID, IH, UsdEmptyComponents>
{
public:
bool findTimeVarying(const char* name, UsdEmptyComponents& component)
{
return false;
}
void setTimeVarying(UsdBridgedBaseObject<IT,ID,IH,UsdEmptyComponents>* bridgedObj, UsdEmptyComponents component, bool value)
{
}
};
bool setTimeVaryingParam(const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device)
{
static const char* paramName = "usd::timeVarying.";
bool value = *(reinterpret_cast<const uint32_t*>(mem));
if (type == ANARI_BOOL)
{
if (strcmp(name, paramName) > 0)
{
const char* secondPart = name + strlen(paramName);
C component;
TimeVaryingClass<T,D,H,C> timevarHelper;
if(timevarHelper.findTimeVarying(secondPart, component))
{
timevarHelper.setTimeVarying(this, component, value);
return true;
}
}
}
return false;
}
bool isTimeVarying(C component) const
{
const D& params = this->getReadParams();
return params.timeVarying & (1 << static_cast<int>(component));
}
bool setRemovePrimParam(const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device)
{
if (type == ANARI_BOOL)
{
if (strcmp(name, "usd::removePrim") == 0)
{
removePrim = true;
return true;
}
}
return false;
}
public:
using ComponentPair = std::pair<C, const char*>; // Used to define a componentParamNames
UsdBridgedBaseObject(ANARIDataType t, const char* name, UsdDevice* device)
: UsdParameterizedBaseObject<T, D>(t, device)
, uniqueName(name)
{
}
H getUsdHandle() const { return usdHandle; }
const char* getName() const override { return this->getReadParams().usdName ? this->getReadParams().usdName->c_str() : uniqueName; }
void filterSetParam(const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device) override
{
if(!this->setTimeVaryingParam(name, type, mem, device))
if (!this->setNameParam(name, type, mem, device))
if(!this->setRemovePrimParam(name, type, mem, device))
this->setParam(name, type, mem, device);
}
int getProperty(const char *name,
ANARIDataType type,
void *mem,
uint64_t size,
UsdDevice* device) override
{
int nameResult = this->getNameProperty(name, type, mem, size, device);
if(!nameResult)
{
UsdBridge* usdBridge = device->getUsdBridge();
if(!usdBridge)
{
reportStatusThroughDevice(UsdLogInfo(device, this, ANARI_OBJECT, nullptr), ANARI_SEVERITY_WARNING, ANARI_STATUS_NO_ERROR,
"%s parameter '%s' cannot be read with getProperty(); it requires a succesful device parameter commit.", getName(), name);
}
if (type == ANARI_STRING && strEquals(name, "usd::primPath"))
{
const char* primPath = usdBridge->GetPrimPath(&usdHandle);
snprintf((char*)mem, size, "%s", primPath);
return 1;
}
else if (type == ANARI_UINT64 && strEquals(name, "usd::primPath.size"))
{
if (Assert64bitStringLengthProperty(size, UsdLogInfo(device, this, ANARI_OBJECT, this->getName()), "usd::primPath.size"))
{
const char* primPath = usdBridge->GetPrimPath(&usdHandle);
uint64_t nameLen = strlen(primPath)+1;
memcpy(mem, &nameLen, size);
}
return 1;
}
}
return nameResult;
}
virtual void commit(UsdDevice* device) override
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
cachedBridge = device->getUsdBridge();
#endif
UsdParameterizedBaseObject<T, D>::commit(device);
}
double selectObjTime(double objTimeStep, double worldTimeStep)
{
return
#ifdef VALUE_CLIP_RETIMING
!std::isnan(objTimeStep) ? objTimeStep :
#endif
worldTimeStep;
}
double selectRefTime(double refTimeStep, double objTimeStep, double worldTimeStep)
{
return
#ifdef VALUE_CLIP_RETIMING
!std::isnan(refTimeStep) ? refTimeStep :
(!std::isnan(objTimeStep) ? objTimeStep : worldTimeStep);
#else
worldTimeStep;
#endif
}
bool getRemovePrim() const { return removePrim; }
protected:
typedef UsdBridgedBaseObject<T,D,H,C> BridgedBaseObjectType;
typedef void (UsdBridge::*UsdBridgeMemFn)(H handle);
void applyRemoveFunc(UsdDevice* device, UsdBridgeMemFn func)
{
UsdBridge* usdBridge = device->getUsdBridge();
if(usdBridge && usdHandle.value)
(usdBridge->*func)(usdHandle);
}
const char* uniqueName;
H usdHandle;
bool removePrim = false;
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
UsdBridge* cachedBridge = nullptr;
#endif
};
template<typename T, typename D, typename H, typename C>
inline bool UsdObjectNotInitialized(const UsdBridgedBaseObject<T,D,H,C>* obj)
{
return obj && !obj->getUsdHandle().value;
}
template<typename T>
inline bool UsdObjectNotInitialized(UsdDataArray* objects)
{
if (!objects)
return false;
bool notInitialized = false;
if(anari::isObject(objects->getType()))
{
const T* const * object = reinterpret_cast<const T* const *>(objects->getData());
uint64_t numObjects = objects->getLayout().numItems1;
for(int i = 0; i < numObjects; ++i)
{
notInitialized = notInitialized || UsdObjectNotInitialized(object[i]);
}
}
return notInitialized;
} | 7,017 | C | 27.644898 | 136 | 0.629899 |
NVIDIA-Omniverse/AnariUsdDevice/UsdGroup.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
#include "UsdBridge.h"
class UsdDevice;
class UsdDataArray;
enum class UsdGroupComponents
{
SURFACES = 0,
VOLUMES
};
struct UsdGroupData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
int timeVarying = 0xFFFFFFFF; // Bitmask indicating which attributes are time-varying.
UsdDataArray* surfaces = nullptr;
UsdDataArray* volumes = nullptr;
};
class UsdGroup : public UsdBridgedBaseObject<UsdGroup, UsdGroupData, UsdGroupHandle, UsdGroupComponents>
{
public:
UsdGroup(const char* name, UsdDevice* device);
~UsdGroup();
void remove(UsdDevice* device) override;
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(UsdGroupComponents::SURFACES, "surface"),
ComponentPair(UsdGroupComponents::VOLUMES, "volume")};
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override;
std::vector<UsdSurfaceHandle> surfaceHandles; // for convenience
std::vector<UsdVolumeHandle> volumeHandles; // for convenience
};
typedef void (UsdBridge::*SetRefFunc)(UsdGroupHandle, const UsdSurfaceHandle*, uint64_t, bool, double);
template<int ChildAnariTypeEnum, typename ChildAnariType, typename ChildUsdType,
typename ParentHandleType, typename ChildHandleType>
void ManageRefArray(ParentHandleType parentHandle, UsdDataArray* childArray, bool refsTimeVarying, double timeStep, std::vector<ChildHandleType>& tempChildHandles,
void (UsdBridge::*SetRefFunc)(ParentHandleType, const ChildHandleType*, uint64_t, bool, double), void (UsdBridge::*DeleteRefFunc)(ParentHandleType, bool, double),
UsdBridge* usdBridge, UsdLogInfo& logInfo, const char* typeErrorMsg)
{
bool validRefs = AssertArrayType(childArray, ChildAnariTypeEnum, logInfo, typeErrorMsg);
if(validRefs)
{
if (childArray)
{
const ChildAnariType* children = reinterpret_cast<const ChildAnariType*>(childArray->getData());
uint64_t numChildren = childArray->getLayout().numItems1;
tempChildHandles.resize(numChildren);
for (uint64_t i = 0; i < numChildren; ++i)
{
const ChildUsdType* usdChild = reinterpret_cast<const ChildUsdType*>(children[i]);
tempChildHandles[i] = usdChild->getUsdHandle();
}
(usdBridge->*SetRefFunc)(parentHandle, tempChildHandles.data(), numChildren, refsTimeVarying, timeStep);
}
else
{
(usdBridge->*DeleteRefFunc)(parentHandle, refsTimeVarying, timeStep);
}
}
} | 2,658 | C | 32.2375 | 165 | 0.743416 |
NVIDIA-Omniverse/AnariUsdDevice/UsdLibrary.cpp | // Copyright 2023 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdDevice.h"
#include "anari/backend/LibraryImpl.h"
#ifndef USDDevice_INTERFACE
#define USDDevice_INTERFACE
#endif
namespace anari {
namespace usd {
const char **query_extensions();
struct UsdLibrary : public anari::LibraryImpl {
UsdLibrary(void *lib, ANARIStatusCallback defaultStatusCB,
const void *statusCBPtr);
ANARIDevice newDevice(const char *subtype) override;
const char **getDeviceExtensions(const char *deviceType) override;
};
// Definitions ////////////////////////////////////////////////////////////////
UsdLibrary::UsdLibrary(void *lib, ANARIStatusCallback defaultStatusCB,
const void *statusCBPtr)
: anari::LibraryImpl(lib, defaultStatusCB, statusCBPtr) {}
ANARIDevice UsdLibrary::newDevice(const char * /*subtype*/) {
return (ANARIDevice) new UsdDevice(this_library());
}
const char **UsdLibrary::getDeviceExtensions(const char * /*deviceType*/) {
return query_extensions();
}
} // namespace usd
} // namespace anari
// Define library entrypoint //////////////////////////////////////////////////
extern "C" USDDevice_INTERFACE
ANARI_DEFINE_LIBRARY_ENTRYPOINT(usd, handle, scb, scbPtr) {
return (ANARILibrary) new anari::usd::UsdLibrary(handle, scb, scbPtr);
}
| 1,328 | C++ | 27.276595 | 79 | 0.670934 |
NVIDIA-Omniverse/AnariUsdDevice/UsdAnari.cpp | #include "UsdAnari.h"
#include "UsdDevice.h"
#include "UsdDataArray.h"
#include "anari/frontend/type_utility.h"
UsdBridgeType AnariToUsdBridgeType(ANARIDataType anariType)
{
switch (anariType)
{
case ANARI_UINT8: return UsdBridgeType::UCHAR;
case ANARI_UINT8_VEC2: return UsdBridgeType::UCHAR2;
case ANARI_UINT8_VEC3: return UsdBridgeType::UCHAR3;
case ANARI_UINT8_VEC4: return UsdBridgeType::UCHAR4;
case ANARI_INT8: return UsdBridgeType::CHAR;
case ANARI_INT8_VEC2: return UsdBridgeType::CHAR2;
case ANARI_INT8_VEC3: return UsdBridgeType::CHAR3;
case ANARI_INT8_VEC4: return UsdBridgeType::CHAR4;
case ANARI_UFIXED8: return UsdBridgeType::UCHAR;
case ANARI_UFIXED8_VEC2: return UsdBridgeType::UCHAR2;
case ANARI_UFIXED8_VEC3: return UsdBridgeType::UCHAR3;
case ANARI_UFIXED8_VEC4: return UsdBridgeType::UCHAR4;
case ANARI_FIXED8: return UsdBridgeType::CHAR;
case ANARI_FIXED8_VEC2: return UsdBridgeType::CHAR2;
case ANARI_FIXED8_VEC3: return UsdBridgeType::CHAR3;
case ANARI_FIXED8_VEC4: return UsdBridgeType::CHAR4;
case ANARI_UFIXED8_R_SRGB: return UsdBridgeType::UCHAR_SRGB_R;
case ANARI_UFIXED8_RA_SRGB: return UsdBridgeType::UCHAR_SRGB_RA;
case ANARI_UFIXED8_RGB_SRGB: return UsdBridgeType::UCHAR_SRGB_RGB;
case ANARI_UFIXED8_RGBA_SRGB: return UsdBridgeType::UCHAR_SRGB_RGBA;
case ANARI_UINT16: return UsdBridgeType::USHORT;
case ANARI_UINT16_VEC2: return UsdBridgeType::USHORT2;
case ANARI_UINT16_VEC3: return UsdBridgeType::USHORT3;
case ANARI_UINT16_VEC4: return UsdBridgeType::USHORT4;
case ANARI_INT16: return UsdBridgeType::SHORT;
case ANARI_INT16_VEC2: return UsdBridgeType::SHORT2;
case ANARI_INT16_VEC3: return UsdBridgeType::SHORT3;
case ANARI_INT16_VEC4: return UsdBridgeType::SHORT4;
case ANARI_UFIXED16: return UsdBridgeType::USHORT;
case ANARI_UFIXED16_VEC2: return UsdBridgeType::USHORT2;
case ANARI_UFIXED16_VEC3: return UsdBridgeType::USHORT3;
case ANARI_UFIXED16_VEC4: return UsdBridgeType::USHORT4;
case ANARI_FIXED16: return UsdBridgeType::SHORT;
case ANARI_FIXED16_VEC2: return UsdBridgeType::SHORT2;
case ANARI_FIXED16_VEC3: return UsdBridgeType::SHORT3;
case ANARI_FIXED16_VEC4: return UsdBridgeType::SHORT4;
case ANARI_UINT32: return UsdBridgeType::UINT;
case ANARI_UINT32_VEC2: return UsdBridgeType::UINT2;
case ANARI_UINT32_VEC3: return UsdBridgeType::UINT3;
case ANARI_UINT32_VEC4: return UsdBridgeType::UINT4;
case ANARI_INT32: return UsdBridgeType::INT;
case ANARI_INT32_VEC2: return UsdBridgeType::INT2;
case ANARI_INT32_VEC3: return UsdBridgeType::INT3;
case ANARI_INT32_VEC4: return UsdBridgeType::INT4;
case ANARI_UFIXED32: return UsdBridgeType::UINT;
case ANARI_UFIXED32_VEC2: return UsdBridgeType::UINT2;
case ANARI_UFIXED32_VEC3: return UsdBridgeType::UINT3;
case ANARI_UFIXED32_VEC4: return UsdBridgeType::UINT4;
case ANARI_FIXED32: return UsdBridgeType::INT;
case ANARI_FIXED32_VEC2: return UsdBridgeType::INT2;
case ANARI_FIXED32_VEC3: return UsdBridgeType::INT3;
case ANARI_FIXED32_VEC4: return UsdBridgeType::INT4;
case ANARI_UINT64: return UsdBridgeType::ULONG;
case ANARI_UINT64_VEC2: return UsdBridgeType::ULONG2;
case ANARI_UINT64_VEC3: return UsdBridgeType::ULONG3;
case ANARI_UINT64_VEC4: return UsdBridgeType::ULONG4;
case ANARI_INT64: return UsdBridgeType::LONG;
case ANARI_INT64_VEC2: return UsdBridgeType::LONG2;
case ANARI_INT64_VEC3: return UsdBridgeType::LONG3;
case ANARI_INT64_VEC4: return UsdBridgeType::LONG4;
case ANARI_FLOAT32: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_VEC2: return UsdBridgeType::FLOAT2;
case ANARI_FLOAT32_VEC3: return UsdBridgeType::FLOAT3;
case ANARI_FLOAT32_VEC4: return UsdBridgeType::FLOAT4;
case ANARI_FLOAT64: return UsdBridgeType::DOUBLE;
case ANARI_FLOAT64_VEC2: return UsdBridgeType::DOUBLE2;
case ANARI_FLOAT64_VEC3: return UsdBridgeType::DOUBLE3;
case ANARI_FLOAT64_VEC4: return UsdBridgeType::DOUBLE4;
case ANARI_INT32_BOX1: return UsdBridgeType::INT_PAIR;
case ANARI_INT32_BOX2: return UsdBridgeType::INT_PAIR2;
case ANARI_INT32_BOX3: return UsdBridgeType::INT_PAIR3;
case ANARI_INT32_BOX4: return UsdBridgeType::INT_PAIR4;
case ANARI_FLOAT32_BOX1: return UsdBridgeType::FLOAT_PAIR;
case ANARI_FLOAT32_BOX2: return UsdBridgeType::FLOAT_PAIR2;
case ANARI_FLOAT32_BOX3: return UsdBridgeType::FLOAT_PAIR3;
case ANARI_FLOAT32_BOX4: return UsdBridgeType::FLOAT_PAIR4;
case ANARI_UINT64_REGION1: return UsdBridgeType::ULONG_PAIR;
case ANARI_UINT64_REGION2: return UsdBridgeType::ULONG_PAIR2;
case ANARI_UINT64_REGION3: return UsdBridgeType::ULONG_PAIR3;
case ANARI_UINT64_REGION4: return UsdBridgeType::ULONG_PAIR4;
case ANARI_FLOAT32_MAT2: return UsdBridgeType::FLOAT_MAT2;
case ANARI_FLOAT32_MAT3: return UsdBridgeType::FLOAT_MAT3;
case ANARI_FLOAT32_MAT4: return UsdBridgeType::FLOAT_MAT4;
case ANARI_FLOAT32_MAT2x3: return UsdBridgeType::FLOAT_MAT2x3;
case ANARI_FLOAT32_MAT3x4: return UsdBridgeType::FLOAT_MAT3x4;
case ANARI_FLOAT32_QUAT_IJKW: return UsdBridgeType::FLOAT4;
default: return UsdBridgeType::UNDEFINED;
}
}
UsdBridgeType AnariToUsdBridgeType_Flattened(ANARIDataType anariType)
{
switch (anariType)
{
case ANARI_UINT8: return UsdBridgeType::UCHAR;
case ANARI_UINT8_VEC2: return UsdBridgeType::UCHAR;
case ANARI_UINT8_VEC3: return UsdBridgeType::UCHAR;
case ANARI_UINT8_VEC4: return UsdBridgeType::UCHAR;
case ANARI_INT8: return UsdBridgeType::CHAR;
case ANARI_INT8_VEC2: return UsdBridgeType::CHAR;
case ANARI_INT8_VEC3: return UsdBridgeType::CHAR;
case ANARI_INT8_VEC4: return UsdBridgeType::CHAR;
case ANARI_UFIXED8: return UsdBridgeType::UCHAR;
case ANARI_UFIXED8_VEC2: return UsdBridgeType::UCHAR;
case ANARI_UFIXED8_VEC3: return UsdBridgeType::UCHAR;
case ANARI_UFIXED8_VEC4: return UsdBridgeType::UCHAR;
case ANARI_FIXED8: return UsdBridgeType::CHAR;
case ANARI_FIXED8_VEC2: return UsdBridgeType::CHAR;
case ANARI_FIXED8_VEC3: return UsdBridgeType::CHAR;
case ANARI_FIXED8_VEC4: return UsdBridgeType::CHAR;
case ANARI_UFIXED8_R_SRGB: return UsdBridgeType::UCHAR_SRGB_R;
case ANARI_UFIXED8_RA_SRGB: return UsdBridgeType::UCHAR_SRGB_R;
case ANARI_UFIXED8_RGB_SRGB: return UsdBridgeType::UCHAR_SRGB_R;
case ANARI_UFIXED8_RGBA_SRGB: return UsdBridgeType::UCHAR_SRGB_R;
case ANARI_UINT16: return UsdBridgeType::USHORT;
case ANARI_UINT16_VEC2: return UsdBridgeType::USHORT;
case ANARI_UINT16_VEC3: return UsdBridgeType::USHORT;
case ANARI_UINT16_VEC4: return UsdBridgeType::USHORT;
case ANARI_INT16: return UsdBridgeType::SHORT;
case ANARI_INT16_VEC2: return UsdBridgeType::SHORT;
case ANARI_INT16_VEC3: return UsdBridgeType::SHORT;
case ANARI_INT16_VEC4: return UsdBridgeType::SHORT;
case ANARI_UFIXED16: return UsdBridgeType::USHORT;
case ANARI_UFIXED16_VEC2: return UsdBridgeType::USHORT;
case ANARI_UFIXED16_VEC3: return UsdBridgeType::USHORT;
case ANARI_UFIXED16_VEC4: return UsdBridgeType::USHORT;
case ANARI_FIXED16: return UsdBridgeType::SHORT;
case ANARI_FIXED16_VEC2: return UsdBridgeType::SHORT;
case ANARI_FIXED16_VEC3: return UsdBridgeType::SHORT;
case ANARI_FIXED16_VEC4: return UsdBridgeType::SHORT;
case ANARI_UINT32: return UsdBridgeType::UINT;
case ANARI_UINT32_VEC2: return UsdBridgeType::UINT;
case ANARI_UINT32_VEC3: return UsdBridgeType::UINT;
case ANARI_UINT32_VEC4: return UsdBridgeType::UINT;
case ANARI_INT32: return UsdBridgeType::INT;
case ANARI_INT32_VEC2: return UsdBridgeType::INT;
case ANARI_INT32_VEC3: return UsdBridgeType::INT;
case ANARI_INT32_VEC4: return UsdBridgeType::INT;
case ANARI_UFIXED32: return UsdBridgeType::UINT;
case ANARI_UFIXED32_VEC2: return UsdBridgeType::UINT;
case ANARI_UFIXED32_VEC3: return UsdBridgeType::UINT;
case ANARI_UFIXED32_VEC4: return UsdBridgeType::UINT;
case ANARI_FIXED32: return UsdBridgeType::INT;
case ANARI_FIXED32_VEC2: return UsdBridgeType::INT;
case ANARI_FIXED32_VEC3: return UsdBridgeType::INT;
case ANARI_FIXED32_VEC4: return UsdBridgeType::INT;
case ANARI_UINT64: return UsdBridgeType::ULONG;
case ANARI_UINT64_VEC2: return UsdBridgeType::ULONG;
case ANARI_UINT64_VEC3: return UsdBridgeType::ULONG;
case ANARI_UINT64_VEC4: return UsdBridgeType::ULONG;
case ANARI_INT64: return UsdBridgeType::LONG;
case ANARI_INT64_VEC2: return UsdBridgeType::LONG;
case ANARI_INT64_VEC3: return UsdBridgeType::LONG;
case ANARI_INT64_VEC4: return UsdBridgeType::LONG;
case ANARI_FLOAT32: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_VEC2: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_VEC3: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_VEC4: return UsdBridgeType::FLOAT;
case ANARI_FLOAT64: return UsdBridgeType::DOUBLE;
case ANARI_FLOAT64_VEC2: return UsdBridgeType::DOUBLE;
case ANARI_FLOAT64_VEC3: return UsdBridgeType::DOUBLE;
case ANARI_FLOAT64_VEC4: return UsdBridgeType::DOUBLE;
case ANARI_INT32_BOX1: return UsdBridgeType::INT;
case ANARI_INT32_BOX2: return UsdBridgeType::INT;
case ANARI_INT32_BOX3: return UsdBridgeType::INT;
case ANARI_INT32_BOX4: return UsdBridgeType::INT;
case ANARI_FLOAT32_BOX1: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_BOX2: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_BOX3: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_BOX4: return UsdBridgeType::FLOAT;
case ANARI_UINT64_REGION1: return UsdBridgeType::ULONG;
case ANARI_UINT64_REGION2: return UsdBridgeType::ULONG;
case ANARI_UINT64_REGION3: return UsdBridgeType::ULONG;
case ANARI_UINT64_REGION4: return UsdBridgeType::ULONG;
case ANARI_FLOAT32_MAT2: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_MAT3: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_MAT4: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_MAT2x3: return UsdBridgeType::FLOAT;
case ANARI_FLOAT32_MAT3x4: return UsdBridgeType::FLOAT;
default: return UsdBridgeType::UNDEFINED;
}
}
template<int T>
struct AnariTypeStringConverter : public anari::ANARITypeProperties<T>
{
const char* operator()(){ return anari::ANARITypeProperties<T>::enum_name; }
};
const char* AnariTypeToString(ANARIDataType anariType)
{
return anari::anariTypeInvoke<const char*, AnariTypeStringConverter>(anariType);
}
const char* AnariAttributeToUsdName(const char* param, bool perInstance, const UsdLogInfo& logInfo)
{
if(strEquals(param, "worldPosition")
|| strEquals(param, "worldNormal"))
{
reportStatusThroughDevice(logInfo, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdSampler '%s' inAttribute %s not supported, use inTransform parameter on object-space attribute instead.", logInfo.sourceName, param);
}
if(strEquals(param, "objectPosition"))
{
if(perInstance)
return "positions";
else
return "points";
}
else if(strEquals(param, "objectNormal"))
{
return "normals";
}
//else if(!strncmp(param, "attribute", 9))
//{
// return param;
//}
return param; // The generic case just returns the param itself
}
UsdBridgeMaterialData::AlphaModes AnariToUsdAlphaMode(const char* alphaMode)
{
if(alphaMode)
{
if(strEquals(alphaMode, "blend"))
{
return UsdBridgeMaterialData::AlphaModes::BLEND;
}
else if(strEquals(alphaMode, "mask"))
{
return UsdBridgeMaterialData::AlphaModes::MASK;
}
}
return UsdBridgeMaterialData::AlphaModes::NONE;
}
ANARIStatusSeverity UsdBridgeLogLevelToAnariSeverity(UsdBridgeLogLevel level)
{
ANARIStatusSeverity severity = ANARI_SEVERITY_INFO;
switch (level)
{
case UsdBridgeLogLevel::STATUS: severity = ANARI_SEVERITY_INFO; break;
case UsdBridgeLogLevel::WARNING: severity = ANARI_SEVERITY_WARNING; break;
case UsdBridgeLogLevel::ERR: severity = ANARI_SEVERITY_ERROR; break;
default: severity = ANARI_SEVERITY_INFO; break;
}
return severity;
}
void reportStatusThroughDevice(const UsdLogInfo& logInfo, ANARIStatusSeverity severity, ANARIStatusCode statusCode,
const char *format, const char* firstArg, const char* secondArg)
{
if(logInfo.device)
logInfo.device->reportStatus(logInfo.source, logInfo.sourceType, severity, statusCode, format, firstArg, secondArg);
}
#ifdef CHECK_MEMLEAKS
void logAllocationThroughDevice(UsdDevice* device, const void* ptr, ANARIDataType ptrType)
{
if(anari::isObject(ptrType))
device->LogObjAllocation((const UsdBaseObject*)ptr);
else if(ptrType == ANARI_STRING)
device->LogStrAllocation((const UsdSharedString*)ptr);
else
device->LogRawAllocation(ptr);
}
void logDeallocationThroughDevice(UsdDevice* device, const void* ptr, ANARIDataType ptrType)
{
if(anari::isObject(ptrType))
device->LogObjDeallocation((const UsdBaseObject*)ptr);
else if(ptrType == ANARI_STRING)
device->LogStrDeallocation((const UsdSharedString*)ptr);
else
device->LogRawDeallocation(ptr);
}
#endif
bool Assert64bitStringLengthProperty(uint64_t size, const UsdLogInfo& logInfo, const char* name)
{
if (size != sizeof(uint64_t) && logInfo.device)
{
logInfo.device->reportStatus(logInfo.source, ANARI_OBJECT, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"On object '%s', getProperty() on %s, size parameter differs from sizeof(uint64_t)", logInfo.sourceName, name);
return false;
}
return true;
}
bool AssertOneDimensional(const UsdDataLayout& layout, const UsdLogInfo& logInfo, const char* arrayName)
{
if (!layout.isOneDimensional() && logInfo.device)
{
logInfo.device->reportStatus(logInfo.source, logInfo.sourceType, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "On object '%s', '%s' array has to be 1-dimensional.", logInfo.sourceName, arrayName);
return false;
}
return true;
}
bool AssertNoStride(const UsdDataLayout& layout, const UsdLogInfo& logInfo, const char* arrayName)
{
if (!layout.isDense() && logInfo.device)
{
logInfo.device->reportStatus(logInfo.source, logInfo.sourceType, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "On object '%s', '%s' layout strides should all be 0.", logInfo.sourceName, arrayName);
return false;
}
return true;
}
bool AssertArrayType(UsdDataArray* dataArray, ANARIDataType dataType, const UsdLogInfo& logInfo, const char* errorMessage)
{
if (dataArray && dataArray->getType() != dataType && logInfo.device)
{
logInfo.device->reportStatus(logInfo.source, logInfo.sourceType, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "On object '%s', '%s'", logInfo.sourceName, errorMessage);
return false;
}
return true;
} | 14,507 | C++ | 39.638655 | 209 | 0.766044 |
NVIDIA-Omniverse/AnariUsdDevice/UsdSpatialField.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdSpatialField.h"
#include "UsdAnari.h"
#include "UsdDataArray.h"
#include "UsdDevice.h"
#include "UsdVolume.h"
#include <algorithm>
DEFINE_PARAMETER_MAP(UsdSpatialField,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::time", ANARI_FLOAT64, timeStep)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("data", ANARI_ARRAY, data)
REGISTER_PARAMETER_MACRO("spacing", ANARI_FLOAT32_VEC3, gridSpacing)
REGISTER_PARAMETER_MACRO("origin", ANARI_FLOAT32_VEC3, gridOrigin)
) // See .h for usage.
constexpr UsdSpatialField::ComponentPair UsdSpatialField::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
UsdSpatialField::UsdSpatialField(const char* name, const char* type, UsdDevice* device)
: BridgedBaseObjectType(ANARI_SPATIAL_FIELD, name, device)
{
}
UsdSpatialField::~UsdSpatialField()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
if(cachedBridge)
cachedBridge->DeleteSpatialField(usdHandle);
#endif
}
void UsdSpatialField::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteSpatialField);
}
bool UsdSpatialField::deferCommit(UsdDevice* device)
{
// Always defer until flushing of commit list, to give parent volumes the possibility to detect which of its child fields have been committed,
// such that those volumes with committed children are also automatically committed.
return !device->isFlushingCommitList();
}
bool UsdSpatialField::doCommitData(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
const UsdSpatialFieldData& paramData = getReadParams();
const char* debugName = getName();
UsdLogInfo logInfo(device, this, ANARI_SPATIAL_FIELD, debugName);
bool isNew = false;
if(!usdHandle.value)
isNew = usdBridge->CreateSpatialField(debugName, usdHandle);
// Only perform type checks, actual data gets uploaded during UsdVolume::commit()
const UsdDataArray* fieldDataArray = paramData.data;
if (!fieldDataArray)
{
device->reportStatus(this, ANARI_SPATIAL_FIELD, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_OPERATION,
"UsdSpatialField '%s' commit failed: data missing.", debugName);
return false;
}
const UsdDataLayout& dataLayout = fieldDataArray->getLayout();
if (!AssertNoStride(dataLayout, logInfo, "data"))
return false;
switch (fieldDataArray->getType())
{
case ANARI_INT8:
case ANARI_UINT8:
case ANARI_INT16:
case ANARI_UINT16:
case ANARI_INT32:
case ANARI_UINT32:
case ANARI_INT64:
case ANARI_UINT64:
case ANARI_FLOAT32:
case ANARI_FLOAT64:
break;
default:
device->reportStatus(this, ANARI_SPATIAL_FIELD, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdSpatialField '%s' commit failed: incompatible data type.", debugName);
return false;
}
// Make sure that parameters are set a first time
paramChanged = paramChanged || isNew;
return false;
} | 3,105 | C++ | 30.693877 | 144 | 0.750725 |
NVIDIA-Omniverse/AnariUsdDevice/UsdSpatialField.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdBridgedBaseObject.h"
class UsdDataArray;
class UsdVolume;
enum class UsdSpatialFieldComponents
{
DATA = 0 // includes spacing and origin
};
struct UsdSpatialFieldData
{
UsdSharedString* name = nullptr;
UsdSharedString* usdName = nullptr;
double timeStep = 0.0;
int timeVarying = 0xFFFFFFFF; // Bitmask indicating which attributes are time-varying.
const UsdDataArray* data = nullptr;
float gridSpacing[3] = {1.0f, 1.0f, 1.0f};
float gridOrigin[3] = {1.0f, 1.0f, 1.0f};
//int filter = 0;
//int gradientFilter = 0;
};
class UsdSpatialField : public UsdBridgedBaseObject<UsdSpatialField, UsdSpatialFieldData, UsdSpatialFieldHandle, UsdSpatialFieldComponents>
{
public:
UsdSpatialField(const char* name, const char* type, UsdDevice* device);
~UsdSpatialField();
void remove(UsdDevice* device) override;
friend class UsdVolume;
static constexpr ComponentPair componentParamNames[] = {
ComponentPair(UsdSpatialFieldComponents::DATA, "data")};
protected:
bool deferCommit(UsdDevice* device) override;
bool doCommitData(UsdDevice* device) override;
void doCommitRefs(UsdDevice* device) override {}
void toBridge(UsdDevice* device, const char* debugName);
}; | 1,335 | C | 24.692307 | 139 | 0.734831 |
NVIDIA-Omniverse/AnariUsdDevice/UsdSampler.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdSampler.h"
#include "UsdAnari.h"
#include "UsdDevice.h"
#include "UsdDataArray.h"
DEFINE_PARAMETER_MAP(UsdSampler,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
REGISTER_PARAMETER_MACRO("usd::time", ANARI_FLOAT64, timeStep)
REGISTER_PARAMETER_MACRO("usd::timeVarying", ANARI_INT32, timeVarying)
REGISTER_PARAMETER_MACRO("usd::imageUrl", ANARI_STRING, imageUrl)
REGISTER_PARAMETER_MACRO("inAttribute", ANARI_STRING, inAttribute)
REGISTER_PARAMETER_MACRO("image", ANARI_ARRAY, imageData)
REGISTER_PARAMETER_MACRO("wrapMode", ANARI_STRING, wrapS)
REGISTER_PARAMETER_MACRO("wrapMode1", ANARI_STRING, wrapS)
REGISTER_PARAMETER_MACRO("wrapMode2", ANARI_STRING, wrapT)
REGISTER_PARAMETER_MACRO("wrapMode3", ANARI_STRING, wrapR)
)
constexpr UsdSampler::ComponentPair UsdSampler::componentParamNames[]; // Workaround for C++14's lack of inlining constexpr arrays
namespace
{
UsdBridgeSamplerData::WrapMode ANARIToUsdBridgeWrapMode(const char* anariWrapMode)
{
UsdBridgeSamplerData::WrapMode usdWrapMode = UsdBridgeSamplerData::WrapMode::BLACK;
if(anariWrapMode)
{
if (strEquals(anariWrapMode, "clampToEdge"))
{
usdWrapMode = UsdBridgeSamplerData::WrapMode::CLAMP;
}
else if (strEquals(anariWrapMode, "repeat"))
{
usdWrapMode = UsdBridgeSamplerData::WrapMode::REPEAT;
}
else if (strEquals(anariWrapMode, "mirrorRepeat"))
{
usdWrapMode = UsdBridgeSamplerData::WrapMode::MIRROR;
}
}
return usdWrapMode;
}
}
UsdSampler::UsdSampler(const char* name, const char* type, UsdDevice* device)
: BridgedBaseObjectType(ANARI_SAMPLER, name, device)
{
if (strEquals(type, "image1D"))
samplerType = SAMPLER_1D;
else if (strEquals(type, "image2D"))
samplerType = SAMPLER_2D;
else if (strEquals(type, "image3D"))
samplerType = SAMPLER_3D;
else
device->reportStatus(this, ANARI_SAMPLER, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT, "UsdSampler '%s' construction failed: type %s not supported", getName(), name);
}
UsdSampler::~UsdSampler()
{
#ifdef OBJECT_LIFETIME_EQUALS_USD_LIFETIME
if(cachedBridge)
cachedBridge->DeleteSampler(usdHandle);
#endif
}
void UsdSampler::remove(UsdDevice* device)
{
applyRemoveFunc(device, &UsdBridge::DeleteSampler);
}
void UsdSampler::updateBoundParameters(bool boundToInstance, UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
if(!usdHandle.value)
return;
if(perInstance != boundToInstance)
{
// Fix up the position attribute
const UsdSamplerData& paramData = getReadParams();
const char* inAttribName = UsdSharedString::c_str(paramData.inAttribute);
if(inAttribName && strEquals(inAttribName, "objectPosition"))
{
// In case of a per-instance specific attribute name, there can be only one change of the attribute name.
UsdLogInfo logInfo(device, this, ANARI_SAMPLER, getName());
if(instanceAttributeAttached)
{
reportStatusThroughDevice(logInfo, ANARI_SEVERITY_WARNING, ANARI_STATUS_INVALID_ARGUMENT,
"UsdSampler '%s' binds its inAttribute parameter to %s, but is transitively bound to both an instanced geometry (cones, spheres, cylinders) and regular geometry. \
This is incompatible with USD, which demands a differently bound name for those categories. \
Please create two different samplers and bind each to only one of both categories of geometry. \
The inAttribute value will be updated, but may therefore invalidate previous bindings to the objectPosition attribute.", logInfo.sourceName, "'objectPosition'");
}
instanceAttributeAttached = true;
const char* usdAttribName = AnariAttributeToUsdName(inAttribName, perInstance, logInfo);
double worldTimeStep = device->getReadParams().timeStep;
double dataTimeStep = selectObjTime(paramData.timeStep, worldTimeStep);
UsdBridgeSamplerData::DataMemberId timeVarying;
setSamplerTimeVarying(timeVarying);
usdBridge->ChangeInAttribute(usdHandle, usdAttribName, dataTimeStep, timeVarying);
}
perInstance = boundToInstance;
}
}
bool UsdSampler::deferCommit(UsdDevice* device)
{
return false;
}
bool UsdSampler::doCommitData(UsdDevice* device)
{
UsdBridge* usdBridge = device->getUsdBridge();
if(!device->getReadParams().outputMaterial ||
samplerType == SAMPLER_UNKNOWN)
return false;
const UsdSamplerData& paramData = getReadParams();
UsdBridgeSamplerData::SamplerType type =
(samplerType == SAMPLER_1D ? UsdBridgeSamplerData::SamplerType::SAMPLER_1D :
(samplerType == SAMPLER_2D ? UsdBridgeSamplerData::SamplerType::SAMPLER_2D :
UsdBridgeSamplerData::SamplerType::SAMPLER_3D
)
);
bool isNew = false;
if (!usdHandle.value)
isNew = usdBridge->CreateSampler(getName(), usdHandle, type);
if (paramChanged || isNew)
{
if (paramData.inAttribute && (std::strlen(UsdSharedString::c_str(paramData.inAttribute)) > 0)
&& (paramData.imageUrl || paramData.imageData))
{
bool supportedImage = true;
int numComponents = 0;
if(paramData.imageData)
{
numComponents = static_cast<int>(anari::componentsOf(paramData.imageData->getType()));
if(numComponents > 4)
device->reportStatus(this, ANARI_SAMPLER, ANARI_SEVERITY_WARNING, ANARI_STATUS_INVALID_ARGUMENT,
"UsdSampler '%s' image data has more than 4 components. Anything above the 4th component will be ignored.", paramData.imageData->getName());
}
if(supportedImage)
{
UsdLogInfo logInfo(device, this, ANARI_SAMPLER, getName());
UsdBridgeSamplerData samplerData;
samplerData.Type = type;
double worldTimeStep = device->getReadParams().timeStep;
double dataTimeStep = selectObjTime(paramData.timeStep, worldTimeStep);
samplerData.InAttribute = AnariAttributeToUsdName(UsdSharedString::c_str(paramData.inAttribute), perInstance, logInfo);
if(paramData.imageUrl)
{
samplerData.ImageUrl = UsdSharedString::c_str(paramData.imageUrl);
}
if(paramData.imageData)
{
samplerData.Data = paramData.imageData->getData();
samplerData.ImageName = paramData.imageData->getName();
samplerData.ImageNumComponents = numComponents;
samplerData.DataType = AnariToUsdBridgeType(paramData.imageData->getType());
paramData.imageData->getLayout().copyDims(samplerData.ImageDims);
paramData.imageData->getLayout().copyStride(samplerData.ImageStride);
}
samplerData.WrapS = ANARIToUsdBridgeWrapMode(UsdSharedString::c_str(paramData.wrapS));
samplerData.WrapT = ANARIToUsdBridgeWrapMode(UsdSharedString::c_str(paramData.wrapT));
samplerData.WrapR = ANARIToUsdBridgeWrapMode(UsdSharedString::c_str(paramData.wrapR));
setSamplerTimeVarying(samplerData.TimeVarying);
usdBridge->SetSamplerData(usdHandle, samplerData, dataTimeStep);
}
}
else
{
device->reportStatus(this, ANARI_SAMPLER, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_ARGUMENT,
"UsdSampler '%s' commit failed: missing either the 'inAttribute', or both the 'image' and 'usd::imageUrl' parameter", getName());
}
paramChanged = false;
}
return false;
}
void UsdSampler::setSamplerTimeVarying(UsdBridgeSamplerData::DataMemberId& timeVarying)
{
typedef UsdBridgeSamplerData::DataMemberId DMI;
timeVarying = DMI::ALL
& (isTimeVarying(CType::DATA) ? DMI::ALL : ~DMI::DATA)
& (isTimeVarying(CType::WRAPS) ? DMI::ALL : ~DMI::WRAPS)
& (isTimeVarying(CType::WRAPT) ? DMI::ALL : ~DMI::WRAPT)
& (isTimeVarying(CType::WRAPR) ? DMI::ALL : ~DMI::WRAPR);
}
| 7,952 | C++ | 35.649769 | 178 | 0.709633 |
NVIDIA-Omniverse/AnariUsdDevice/UsdMultiTypeParameter.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "UsdAnari.h"
#include "anari/anari_cpp/Traits.h"
template<typename T0, typename T1, typename T2>
struct UsdMultiTypeParameter
{
static constexpr int AnariType0 = anari::ANARITypeFor<T0>::value;
static constexpr int AnariType1 = anari::ANARITypeFor<T1>::value;
static constexpr int AnariType2 = anari::ANARITypeFor<T2>::value;
union DataUnion
{
T0 type0;
T1 type1;
T2 type2;
};
DataUnion data;
ANARIDataType type;
// Helper functions
T0& Get(T0& arg) const
{
if(AnariType0 == type) { arg = data.type0; }
return arg;
}
T1& Get(T1& arg) const
{
if(AnariType1 == type) { arg = data.type1; }
return arg;
}
T2& Get(T2& arg) const
{
if(AnariType2 == type) { arg = data.type2; }
return arg;
}
};
| 876 | C | 17.659574 | 67 | 0.64726 |
NVIDIA-Omniverse/AnariUsdDevice/UsdLight.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdLight.h"
#include "UsdAnari.h"
#include "UsdDevice.h"
DEFINE_PARAMETER_MAP(UsdLight,
REGISTER_PARAMETER_MACRO("name", ANARI_STRING, name)
REGISTER_PARAMETER_MACRO("usd::name", ANARI_STRING, usdName)
)
UsdLight::UsdLight(const char* name, UsdDevice* device)
: BridgedBaseObjectType(ANARI_LIGHT, name, device)
{}
UsdLight::~UsdLight()
{}
void UsdLight::remove(UsdDevice* device)
{
//applyRemoveFunc(device, &UsdBridge::DeleteLight);
}
bool UsdLight::deferCommit(UsdDevice* device)
{
return false;
}
bool UsdLight::doCommitData(UsdDevice* device)
{
return false;
} | 672 | C++ | 19.393939 | 62 | 0.735119 |
NVIDIA-Omniverse/AnariUsdDevice/UsdDevice.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdDevice.h"
#include "UsdBridgedBaseObject.h"
#include "UsdDataArray.h"
#include "UsdGeometry.h"
#include "UsdSpatialField.h"
#include "UsdSurface.h"
#include "UsdVolume.h"
#include "UsdInstance.h"
#include "UsdGroup.h"
#include "UsdMaterial.h"
#include "UsdSampler.h"
#include "UsdWorld.h"
#include "UsdRenderer.h"
#include "UsdFrame.h"
#include "UsdLight.h"
#include "UsdCamera.h"
#include "UsdDeviceQueries.h"
#include <cstdarg>
#include <cstdio>
#include <set>
#include <memory>
#include <sstream>
#include <algorithm>
#include <limits>
static char deviceName[] = "usd";
class UsdDeviceInternals
{
public:
UsdDeviceInternals()
{
}
bool CreateNewBridge(const UsdDeviceData& deviceParams, UsdBridgeLogCallback bridgeStatusFunc, void* userData)
{
if (bridge.get())
bridge->CloseSession();
UsdBridgeSettings bridgeSettings = {
UsdSharedString::c_str(deviceParams.hostName),
outputLocation.c_str(),
deviceParams.createNewSession,
deviceParams.outputBinary,
deviceParams.outputPreviewSurfaceShader,
deviceParams.outputMdlShader
};
bridge = std::make_unique<UsdBridge>(bridgeSettings);
bridge->SetExternalSceneStage(externalSceneStage);
bridge->SetEnableSaving(this->enableSaving);
bridgeStatusFunc(UsdBridgeLogLevel::STATUS, userData, "Initializing UsdBridge Session");
bool createSuccess = bridge->OpenSession(bridgeStatusFunc, userData);
if (!createSuccess)
{
bridge = nullptr;
bridgeStatusFunc(UsdBridgeLogLevel::STATUS, userData, "UsdBridge Session initialization failed.");
}
else
{
bridgeStatusFunc(UsdBridgeLogLevel::STATUS, userData, "UsdBridge Session initialization successful.");
}
return createSuccess;
}
std::string outputLocation;
bool enableSaving = true;
std::unique_ptr<UsdBridge> bridge;
SceneStagePtr externalSceneStage{nullptr};
std::set<std::string> uniqueNames;
};
//---- Make sure to update clearDeviceParameters() on refcounted objects
DEFINE_PARAMETER_MAP(UsdDevice,
REGISTER_PARAMETER_MACRO("usd::serialize.hostName", ANARI_STRING, hostName)
REGISTER_PARAMETER_MACRO("usd::serialize.location", ANARI_STRING, outputPath)
REGISTER_PARAMETER_MACRO("usd::serialize.newSession", ANARI_BOOL, createNewSession)
REGISTER_PARAMETER_MACRO("usd::serialize.outputBinary", ANARI_BOOL, outputBinary)
REGISTER_PARAMETER_MACRO("usd::time", ANARI_FLOAT64, timeStep)
REGISTER_PARAMETER_MACRO("usd::writeAtCommit", ANARI_BOOL, writeAtCommit)
REGISTER_PARAMETER_MACRO("usd::output.material", ANARI_BOOL, outputMaterial)
REGISTER_PARAMETER_MACRO("usd::output.previewSurfaceShader", ANARI_BOOL, outputPreviewSurfaceShader)
REGISTER_PARAMETER_MACRO("usd::output.mdlShader", ANARI_BOOL, outputMdlShader)
)
void UsdDevice::clearDeviceParameters()
{
filterResetParam("usd::serialize.hostName");
filterResetParam("usd::serialize.location");
transferWriteToReadParams();
}
//----
UsdDevice::UsdDevice()
: UsdParameterizedBaseObject<UsdDevice, UsdDeviceData>(ANARI_DEVICE)
, internals(std::make_unique<UsdDeviceInternals>())
{}
UsdDevice::UsdDevice(ANARILibrary library)
: DeviceImpl(library)
, UsdParameterizedBaseObject<UsdDevice, UsdDeviceData>(ANARI_DEVICE)
, internals(std::make_unique<UsdDeviceInternals>())
{}
UsdDevice::~UsdDevice()
{
// Make sure no more references are held before cleaning up the device (and checking for memleaks)
clearCommitList();
clearDeviceParameters(); // Release device parameters with object references
clearResourceStringList(); // Do the same for resource string references
//internals->bridge->SaveScene(); //Uncomment to test cleanup of usd files.
#ifdef CHECK_MEMLEAKS
if(!allocatedObjects.empty() || !allocatedStrings.empty() || !allocatedRawMemory.empty())
{
std::stringstream errstream;
errstream << "USD Device memleak reported for: ";
for(auto ptr : allocatedObjects)
errstream << "Object ptr: 0x" << std::hex << ptr << " of type: " << std::dec << ptr->getType() << "; ";
for(auto ptr : allocatedStrings)
errstream << "String ptr: 0x" << std::hex << ptr << " with content: " << std::dec << ptr->c_str() << "; ";
for(auto ptr : allocatedRawMemory)
errstream << "Raw ptr: 0x" << std::hex << ptr << std::dec << "; ";
reportStatus(this, ANARI_DEVICE, ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_OPERATION, errstream.str().c_str());
}
else
{
reportStatus(this, ANARI_DEVICE, ANARI_SEVERITY_INFO, ANARI_STATUS_NO_ERROR, "Reference memleak check complete, no issues found.");
}
assert(allocatedObjects.empty());
#endif
}
void UsdDevice::reportStatus(void* source,
ANARIDataType sourceType,
ANARIStatusSeverity severity,
ANARIStatusCode statusCode,
const char *format, ...)
{
va_list arglist;
va_start(arglist, format);
reportStatus(source, sourceType, severity, statusCode, format, arglist);
va_end(arglist);
}
static void reportBridgeStatus(UsdBridgeLogLevel level, void* device, const char *message)
{
ANARIStatusSeverity severity = UsdBridgeLogLevelToAnariSeverity(level);
va_list arglist;
((UsdDevice*)device)->reportStatus(nullptr, ANARI_UNKNOWN, severity, ANARI_STATUS_NO_ERROR, message, arglist);
}
void UsdDevice::reportStatus(void* source,
ANARIDataType sourceType,
ANARIStatusSeverity severity,
ANARIStatusCode statusCode,
const char *format,
va_list& arglist)
{
va_list arglist_copy;
va_copy(arglist_copy, arglist);
int count = std::vsnprintf(nullptr, 0, format, arglist);
lastStatusMessage.resize(count + 1);
std::vsnprintf(lastStatusMessage.data(), count + 1, format, arglist_copy);
va_end(arglist_copy);
if (statusFunc != nullptr)
{
statusFunc(
statusUserData,
(ANARIDevice)this,
(ANARIObject)source,
sourceType,
severity,
statusCode,
lastStatusMessage.data());
}
}
void UsdDevice::filterSetParam(
const char *name,
ANARIDataType type,
const void *mem,
UsdDevice* device)
{
if (strEquals(name, "usd::garbageCollect"))
{
// Perform garbage collection on usd objects (needs to move into the user interface)
if(internals->bridge)
internals->bridge->GarbageCollect();
}
else if(strEquals(name, "usd::removeUnusedNames"))
{
internals->uniqueNames.clear();
}
else if (strEquals(name, "usd::connection.logVerbosity")) // 0 <= verbosity <= 4, with 4 being the loudest
{
if(type == ANARI_INT32)
UsdBridge::SetConnectionLogVerbosity(*(reinterpret_cast<const int*>(mem)));
}
else if(strEquals(name, "usd::sceneStage"))
{
if(type == ANARI_VOID_POINTER)
internals->externalSceneStage = const_cast<void *>(mem);
}
else if (strEquals(name, "usd::enableSaving"))
{
if(type == ANARI_BOOL)
{
internals->enableSaving = *(reinterpret_cast<const bool*>(mem));
if(internals->bridge)
internals->bridge->SetEnableSaving(internals->enableSaving);
}
}
else if (strEquals(name, "statusCallback") && type == ANARI_STATUS_CALLBACK)
{
userSetStatusFunc = (ANARIStatusCallback)mem;
}
else if (strEquals(name, "statusCallbackUserData") && type == ANARI_VOID_POINTER)
{
userSetStatusUserData = const_cast<void *>(mem);
}
else
{
setParam(name, type, mem, this);
}
}
void UsdDevice::filterResetParam(const char * name)
{
if (strEquals(name, "statusCallback"))
{
userSetStatusFunc = nullptr;
}
else if (strEquals(name, "statusCallbackUserData"))
{
userSetStatusUserData = nullptr;
}
else if (!strEquals(name, "usd::garbageCollect")
&& !strEquals(name, "usd::removeUnusedNames"))
{
resetParam(name);
}
}
void UsdDevice::commit(UsdDevice* device)
{
transferWriteToReadParams();
if(!bridgeInitAttempt)
{
initializeBridge();
}
else
{
const UsdDeviceData& paramData = getReadParams();
internals->bridge->UpdateBeginEndTime(paramData.timeStep);
}
}
void UsdDevice::initializeBridge()
{
const UsdDeviceData& paramData = getReadParams();
bridgeInitAttempt = true;
statusFunc = userSetStatusFunc ? userSetStatusFunc : defaultStatusCallback();
statusUserData = userSetStatusUserData ? userSetStatusUserData : defaultStatusCallbackUserPtr();
if(paramData.outputPath)
internals->outputLocation = paramData.outputPath->c_str();
if(internals->outputLocation.empty()) {
auto *envLocation = getenv("ANARI_USD_SERIALIZE_LOCATION");
if (envLocation) {
internals->outputLocation = envLocation;
reportStatus(this, ANARI_DEVICE, ANARI_SEVERITY_INFO, ANARI_STATUS_NO_ERROR,
"Usd Device parameter 'usd::serialize.location' using ANARI_USD_SERIALIZE_LOCATION value");
}
}
if (internals->outputLocation.empty())
{
reportStatus(this, ANARI_DEVICE, ANARI_SEVERITY_WARNING, ANARI_STATUS_INVALID_ARGUMENT,
"Usd Device parameter 'usd::serialize.location' not set, defaulting to './'");
internals->outputLocation = "./";
}
if (!internals->CreateNewBridge(paramData, &reportBridgeStatus, this))
{
reportStatus(this, ANARI_DEVICE, ANARI_SEVERITY_ERROR, ANARI_STATUS_UNKNOWN_ERROR, "Usd Bridge failed to load");
}
}
ANARIArray UsdDevice::CreateDataArray(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userData,
ANARIDataType dataType,
uint64_t numItems1,
int64_t byteStride1,
uint64_t numItems2,
int64_t byteStride2,
uint64_t numItems3,
int64_t byteStride3)
{
if (!appMemory)
{
UsdDataArray* object = new UsdDataArray(dataType, numItems1, numItems2, numItems3, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIArray)(object);
}
else
{
UsdDataArray* object = new UsdDataArray(appMemory, deleter, userData,
dataType, numItems1, byteStride1, numItems2, byteStride2, numItems3, byteStride3,
this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIArray)(object);
}
}
ANARIArray1D UsdDevice::newArray1D(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userData,
ANARIDataType type,
uint64_t numItems)
{
return (ANARIArray1D)CreateDataArray(appMemory, deleter, userData,
type, numItems, 0, 1, 0, 1, 0);
}
ANARIArray2D UsdDevice::newArray2D(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userData,
ANARIDataType type,
uint64_t numItems1,
uint64_t numItems2)
{
return (ANARIArray2D)CreateDataArray(appMemory, deleter, userData,
type, numItems1, 0, numItems2, 0, 1, 0);
}
ANARIArray3D UsdDevice::newArray3D(const void *appMemory,
ANARIMemoryDeleter deleter,
const void *userData,
ANARIDataType type,
uint64_t numItems1,
uint64_t numItems2,
uint64_t numItems3)
{
return (ANARIArray3D)CreateDataArray(appMemory, deleter, userData,
type, numItems1, 0, numItems2, 0, numItems3, 0);
}
void * UsdDevice::mapArray(ANARIArray array)
{
return array ? AnariToUsdObjectPtr(array)->map(this) : nullptr;
}
void UsdDevice::unmapArray(ANARIArray array)
{
if(array)
AnariToUsdObjectPtr(array)->unmap(this);
}
ANARISampler UsdDevice::newSampler(const char *type)
{
const char* name = makeUniqueName("Sampler");
UsdSampler* object = new UsdSampler(name, type, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARISampler)(object);
}
ANARIMaterial UsdDevice::newMaterial(const char *material_type)
{
const char* name = makeUniqueName("Material");
UsdMaterial* object = new UsdMaterial(name, material_type, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIMaterial)(object);
}
ANARIGeometry UsdDevice::newGeometry(const char *type)
{
const char* name = makeUniqueName("Geometry");
UsdGeometry* object = new UsdGeometry(name, type, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIGeometry)(object);
}
ANARISpatialField UsdDevice::newSpatialField(const char * type)
{
const char* name = makeUniqueName("SpatialField");
UsdSpatialField* object = new UsdSpatialField(name, type, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARISpatialField)(object);
}
ANARISurface UsdDevice::newSurface()
{
const char* name = makeUniqueName("Surface");
UsdSurface* object = new UsdSurface(name, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARISurface)(object);
}
ANARIVolume UsdDevice::newVolume(const char *type)
{
const char* name = makeUniqueName("Volume");
UsdVolume* object = new UsdVolume(name, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIVolume)(object);
}
ANARIGroup UsdDevice::newGroup()
{
const char* name = makeUniqueName("Group");
UsdGroup* object = new UsdGroup(name, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIGroup)(object);
}
ANARIInstance UsdDevice::newInstance(const char */*type*/)
{
const char* name = makeUniqueName("Instance");
UsdInstance* object = new UsdInstance(name, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIInstance)(object);
}
ANARIWorld UsdDevice::newWorld()
{
const char* name = makeUniqueName("World");
UsdWorld* object = new UsdWorld(name, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIWorld)(object);
}
ANARICamera UsdDevice::newCamera(const char *type)
{
const char* name = makeUniqueName("Camera");
UsdCamera* object = new UsdCamera(name, type, this);
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARICamera)(object);
}
const char **UsdDevice::getObjectSubtypes(ANARIDataType objectType)
{
return anari::usd::query_object_types(objectType);
}
const void *UsdDevice::getObjectInfo(ANARIDataType objectType,
const char *objectSubtype,
const char *infoName,
ANARIDataType infoType)
{
return anari::usd::query_object_info(
objectType, objectSubtype, infoName, infoType);
}
const void *UsdDevice::getParameterInfo(ANARIDataType objectType,
const char *objectSubtype,
const char *parameterName,
ANARIDataType parameterType,
const char *infoName,
ANARIDataType infoType)
{
return anari::usd::query_param_info(objectType,
objectSubtype,
parameterName,
parameterType,
infoName,
infoType);
}
ANARIRenderer UsdDevice::newRenderer(const char *type)
{
UsdRenderer* object = new UsdRenderer();
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIRenderer)(object);
}
UsdBridge* UsdDevice::getUsdBridge()
{
return internals->bridge.get();
}
void UsdDevice::renderFrame(ANARIFrame frame)
{
// Always commit device changes if not initialized, otherwise no conversion can be performed.
if(!bridgeInitAttempt)
initializeBridge();
if(!isInitialized())
return;
flushCommitList();
internals->bridge->ResetResourceUpdateState(); // Reset the modified flags for committed shared resources
if(frame)
AnariToUsdObjectPtr(frame)->saveUsd(this);
}
const char* UsdDevice::makeUniqueName(const char* name)
{
std::string proposedBaseName(name);
proposedBaseName.append("_");
int postFix = 0;
std::string proposedName = proposedBaseName + std::to_string(postFix);
auto empRes = internals->uniqueNames.emplace(proposedName);
while (!empRes.second)
{
++postFix;
proposedName = proposedBaseName + std::to_string(postFix);
empRes = internals->uniqueNames.emplace(proposedName);
}
return empRes.first->c_str();
}
bool UsdDevice::nameExists(const char* name)
{
return internals->uniqueNames.find(name) != internals->uniqueNames.end();
}
void UsdDevice::addToCommitList(UsdBaseObject* object, bool commitData)
{
if(!object)
return;
if(lockCommitList)
{
this->reportStatus(object, object->getType(), ANARI_SEVERITY_FATAL_ERROR, ANARI_STATUS_INVALID_OPERATION,
"Usd device internal error; addToCommitList called while list is locked");
}
else
{
auto it = std::find_if(commitList.begin(), commitList.end(),
[&object](const CommitListType& entry) -> bool { return entry.first.ptr == object; });
if(it == commitList.end())
commitList.emplace_back(CommitListType(object, commitData));
}
}
void UsdDevice::clearCommitList()
{
removePrimsFromUsd(true); // removeList pointers are taken from commitlist
#ifdef CHECK_MEMLEAKS
for(auto& commitEntry : commitList)
{
LogObjDeallocation(commitEntry.first.ptr);
}
#endif
commitList.resize(0);
}
void UsdDevice::flushCommitList()
{
// Automatically perform a new commitdata/commitrefs on volumes which are not committed,
// but for which their (readdata) spatial field is in commitlist. (to update the previous commit)
for(UsdVolume* volume : volumeList)
{
const UsdVolumeData& readParams = volume->getReadParams();
if(readParams.field)
{
//volume not in commitlist
auto volEntry = std::find_if(commitList.begin(), commitList.end(),
[&volume](const CommitListType& entry) -> bool { return entry.first.ptr == volume; });
if(volEntry == commitList.end())
{
auto fieldEntry = std::find_if(commitList.begin(), commitList.end(),
[&readParams](const CommitListType& entry) -> bool { return entry.first.ptr == readParams.field; });
// spatialfield from readParams is in commit list
if(fieldEntry != commitList.end())
{
UsdBaseObject* baseObject = static_cast<UsdBaseObject*>(volume);
bool commitRefs = baseObject->doCommitData(this);
if(commitRefs)
baseObject->doCommitRefs(this);
}
}
}
}
lockCommitList = true;
writeTypeToUsd<(int)ANARI_SAMPLER>();
writeTypeToUsd<(int)ANARI_SPATIAL_FIELD>();
writeTypeToUsd<(int)ANARI_GEOMETRY>();
writeTypeToUsd<(int)ANARI_LIGHT>();
writeTypeToUsd<(int)ANARI_MATERIAL>();
writeTypeToUsd<(int)ANARI_SURFACE>();
writeTypeToUsd<(int)ANARI_VOLUME>();
writeTypeToUsd<(int)ANARI_GROUP>();
writeTypeToUsd<(int)ANARI_INSTANCE>();
writeTypeToUsd<(int)ANARI_WORLD>();
writeTypeToUsd<(int)ANARI_CAMERA>();
removePrimsFromUsd();
clearCommitList();
lockCommitList = false;
}
void UsdDevice::addToVolumeList(UsdVolume* volume)
{
auto it = std::find(volumeList.begin(), volumeList.end(), volume);
if(it == volumeList.end())
volumeList.emplace_back(volume);
}
void UsdDevice::addToResourceStringList(UsdSharedString* string)
{
resourceStringList.push_back(helium::IntrusivePtr<UsdSharedString>(string));
}
void UsdDevice::clearResourceStringList()
{
resourceStringList.resize(0);
}
void UsdDevice::removeFromVolumeList(UsdVolume* volume)
{
auto it = std::find(volumeList.begin(), volumeList.end(), volume);
if(it == volumeList.end())
{
*it = volumeList.back();
volumeList.pop_back();
}
}
template<int typeInt>
void UsdDevice::writeTypeToUsd()
{
for(auto objCommitPair : commitList)
{
auto object = objCommitPair.first;
bool commitData = objCommitPair.second;
if((int)object->getType() == typeInt)
{
using ObjectType = typename AnariToUsdBridgedObject<typeInt>::Type;
ObjectType* typedObj = reinterpret_cast<ObjectType*>(object.ptr);
if(!object->deferCommit(this))
{
bool commitRefs = true;
if(commitData)
commitRefs = object->doCommitData(this);
if(commitRefs)
object->doCommitRefs(this);
}
else
{
this->reportStatus(object.ptr, object->getType(), ANARI_SEVERITY_ERROR, ANARI_STATUS_INVALID_OPERATION,
"User forgot to at least once commit an ANARI child object of parent object '%s'", typedObj->getName());
}
if(typedObj->getRemovePrim())
{
removeList.push_back(object.ptr); // Just raw pointer, removeList is purged upon commitList clear
}
}
}
}
void UsdDevice::removePrimsFromUsd(bool onlyRemoveHandles)
{
if(!onlyRemoveHandles)
{
for(auto baseObj : removeList)
{
baseObj->remove(this);
}
}
removeList.resize(0);
}
int UsdDevice::getProperty(ANARIObject object,
const char *name,
ANARIDataType type,
void *mem,
uint64_t size,
uint32_t mask)
{
if ((void *)object == (void *)this)
{
if (strEquals(name, "version") && type == ANARI_INT32)
{
writeToVoidP(mem, DEVICE_VERSION_BUILD);
return 1;
}
if (strEquals(name, "version.major") && type == ANARI_INT32)
{
writeToVoidP(mem, DEVICE_VERSION_MAJOR);
return 1;
}
if (strEquals(name, "version.minor") && type == ANARI_INT32)
{
writeToVoidP(mem, DEVICE_VERSION_MINOR);
return 1;
}
if (strEquals(name, "version.patch") && type == ANARI_INT32)
{
writeToVoidP(mem, DEVICE_VERSION_PATCH);
return 1;
}
if (strEquals(name, "version.name") && type == ANARI_STRING)
{
snprintf((char*)mem, size, "%s", DEVICE_VERSION_NAME);
return 1;
}
else if (strEquals(name, "version.name.size") && type == ANARI_UINT64)
{
if (Assert64bitStringLengthProperty(size, UsdLogInfo(this, this, ANARI_DEVICE, "UsdDevice"), "version.name.size"))
{
uint64_t nameLen = strlen(DEVICE_VERSION_NAME)+1;
memcpy(mem, &nameLen, size);
}
return 1;
}
else if (strEquals(name, "geometryMaxIndex") && type == ANARI_UINT64)
{
uint64_t maxIndex = std::numeric_limits<uint64_t>::max(); // Only restricted to int for UsdGeomMesh: GetFaceVertexIndicesAttr() takes a VtArray<int>
writeToVoidP(mem, maxIndex);
return 1;
}
else if (strEquals(name, "extension") && type == ANARI_STRING_LIST)
{
writeToVoidP(mem, anari::usd::query_extensions());
return 1;
}
}
else if(object)
return AnariToUsdObjectPtr(object)->getProperty(name, type, mem, size, this);
return 0;
}
ANARIFrame UsdDevice::newFrame()
{
UsdFrame* object = new UsdFrame(internals->bridge.get());
#ifdef CHECK_MEMLEAKS
LogObjAllocation(object);
#endif
return (ANARIFrame)(object);
}
const void * UsdDevice::frameBufferMap(
ANARIFrame fb,
const char *channel,
uint32_t *width,
uint32_t *height,
ANARIDataType *pixelType)
{
if (fb)
return AnariToUsdObjectPtr(fb)->mapBuffer(channel, width, height, pixelType);
return nullptr;
}
void UsdDevice::frameBufferUnmap(ANARIFrame fb, const char *channel)
{
if (fb)
return AnariToUsdObjectPtr(fb)->unmapBuffer(channel);
}
UsdBaseObject* UsdDevice::getBaseObjectPtr(ANARIObject object)
{
return handleIsDevice(object) ? this : (UsdBaseObject*)object;
}
void UsdDevice::setParameter(ANARIObject object,
const char *name,
ANARIDataType type,
const void *mem)
{
if(object)
getBaseObjectPtr(object)->filterSetParam(name, type, mem, this);
}
void UsdDevice::unsetParameter(ANARIObject object, const char * name)
{
if(object)
getBaseObjectPtr(object)->filterResetParam(name);
}
void UsdDevice::unsetAllParameters(ANARIObject object)
{
if(object)
getBaseObjectPtr(object)->resetAllParams();
}
void *UsdDevice::mapParameterArray1D(ANARIObject object,
const char *name,
ANARIDataType dataType,
uint64_t numElements1,
uint64_t *elementStride)
{
auto array = newArray1D(nullptr, nullptr, nullptr, dataType, numElements1);
setParameter(object, name, ANARI_ARRAY1D, &array);
*elementStride = anari::sizeOf(dataType);
AnariToUsdObjectPtr(array)->refDec(helium::RefType::PUBLIC);
return mapArray(array);
}
void *UsdDevice::mapParameterArray2D(ANARIObject object,
const char *name,
ANARIDataType dataType,
uint64_t numElements1,
uint64_t numElements2,
uint64_t *elementStride)
{
auto array = newArray2D(nullptr, nullptr, nullptr, dataType, numElements1, numElements2);
setParameter(object, name, ANARI_ARRAY2D, &array);
*elementStride = anari::sizeOf(dataType);
AnariToUsdObjectPtr(array)->refDec(helium::RefType::PUBLIC);
return mapArray(array);
}
void *UsdDevice::mapParameterArray3D(ANARIObject object,
const char *name,
ANARIDataType dataType,
uint64_t numElements1,
uint64_t numElements2,
uint64_t numElements3,
uint64_t *elementStride)
{
auto array = newArray3D(nullptr,
nullptr,
nullptr,
dataType,
numElements1,
numElements2,
numElements3);
setParameter(object, name, ANARI_ARRAY3D, &array);
*elementStride = anari::sizeOf(dataType);
AnariToUsdObjectPtr(array)->refDec(helium::RefType::PUBLIC);
return mapArray(array);
}
void UsdDevice::unmapParameterArray(ANARIObject object, const char *name)
{
if(!object)
return;
ANARIDataType paramType = ANARI_UNKNOWN;
void* paramAddress = getBaseObjectPtr(object)->getParameter(name, paramType);
if(paramAddress && paramType == ANARI_ARRAY)
{
auto arrayAddress = (ANARIArray*)paramAddress;
if(*arrayAddress)
AnariToUsdObjectPtr(*arrayAddress)->unmap(this);
}
}
void UsdDevice::release(ANARIObject object)
{
if(!object)
return;
UsdBaseObject* baseObject = getBaseObjectPtr(object);
bool privatizeArray = baseObject->getType() == ANARI_ARRAY
&& baseObject->useCount(helium::RefType::INTERNAL) > 0
&& baseObject->useCount(helium::RefType::PUBLIC) == 1;
#ifdef CHECK_MEMLEAKS
if(!handleIsDevice(object))
LogObjDeallocation(baseObject);
#endif
if (baseObject)
baseObject->refDec(helium::RefType::PUBLIC);
if (privatizeArray)
AnariToUsdObjectPtr((ANARIArray)object)->privatize();
}
void UsdDevice::retain(ANARIObject object)
{
if(object)
getBaseObjectPtr(object)->refInc(helium::RefType::PUBLIC);
}
void UsdDevice::commitParameters(ANARIObject object)
{
if(object)
getBaseObjectPtr(object)->commit(this);
}
#ifdef CHECK_MEMLEAKS
namespace
{
template<typename T>
void SharedLogDeallocation(const T* ptr, std::vector<const T*>& allocations, UsdDevice* device)
{
if (ptr)
{
auto it = std::find(allocations.begin(), allocations.end(), ptr);
if(it == allocations.end())
{
std::stringstream errstream;
errstream << "USD Device release of nonexisting or already released/deleted object: 0x" << std::hex << ptr;
device->reportStatus(device, ANARI_DEVICE, ANARI_SEVERITY_FATAL_ERROR, ANARI_STATUS_INVALID_OPERATION, errstream.str().c_str());
}
if(ptr->useCount() == 1)
{
assert(it != allocations.end());
allocations.erase(it);
}
}
}
}
void UsdDevice::LogObjAllocation(const UsdBaseObject* ptr)
{
allocatedObjects.push_back(ptr);
}
void UsdDevice::LogObjDeallocation(const UsdBaseObject* ptr)
{
SharedLogDeallocation(ptr, allocatedObjects, this);
}
void UsdDevice::LogStrAllocation(const UsdSharedString* ptr)
{
allocatedStrings.push_back(ptr);
}
void UsdDevice::LogStrDeallocation(const UsdSharedString* ptr)
{
SharedLogDeallocation(ptr, allocatedStrings, this);
}
void UsdDevice::LogRawAllocation(const void* ptr)
{
allocatedRawMemory.push_back(ptr);
}
void UsdDevice::LogRawDeallocation(const void* ptr)
{
if (ptr)
{
auto it = std::find(allocatedRawMemory.begin(), allocatedRawMemory.end(), ptr);
if(it == allocatedRawMemory.end())
{
std::stringstream errstream;
errstream << "USD Device release of nonexisting or already released/deleted raw memory: 0x" << std::hex << ptr;
reportStatus(this, ANARI_DEVICE, ANARI_SEVERITY_FATAL_ERROR, ANARI_STATUS_INVALID_OPERATION, errstream.str().c_str());
}
else
allocatedRawMemory.erase(it);
}
}
#endif
| 27,549 | C++ | 25.695736 | 154 | 0.705652 |
NVIDIA-Omniverse/AnariUsdDevice/UsdRenderer.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdRenderer.h"
#include "UsdBridge/UsdBridge.h"
#include "UsdAnari.h"
#include "UsdDevice.h"
#include "UsdDeviceQueries.h"
DEFINE_PARAMETER_MAP(UsdRenderer,
)
UsdRenderer::UsdRenderer()
: UsdParameterizedBaseObject<UsdRenderer, UsdRendererData>(ANARI_RENDERER)
{
}
UsdRenderer::~UsdRenderer()
{
}
int UsdRenderer::getProperty(const char * name, ANARIDataType type, void * mem, uint64_t size, UsdDevice* device)
{
if (strEquals(name, "extension") && type == ANARI_STRING_LIST)
{
writeToVoidP(mem, anari::usd::query_extensions());
return 1;
}
return 0;
}
bool UsdRenderer::deferCommit(UsdDevice* device)
{
return false;
}
bool UsdRenderer::doCommitData(UsdDevice* device)
{
return false;
}
| 803 | C++ | 18.142857 | 113 | 0.728518 |
NVIDIA-Omniverse/AnariUsdDevice/UsdSharedObjects.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "helium/utility/IntrusivePtr.h"
#include "UsdCommonMacros.h"
#include <string>
template<typename BaseType, typename InitType>
class UsdRefCountWrapped : public helium::RefCounted
{
public:
UsdRefCountWrapped(InitType i)
: data(i)
{}
BaseType data;
};
class UsdSharedString : public UsdRefCountWrapped<std::string, const char*>
{
public:
UsdSharedString(const char* cStr)
: UsdRefCountWrapped<std::string, const char*>(cStr)
{}
static const char* c_str(const UsdSharedString* string) { return string ? string->c_str() : nullptr; }
const char* c_str() const { return data.c_str(); }
}; | 733 | C | 22.677419 | 106 | 0.699864 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBaseObject.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBaseObject.h"
#include "UsdDevice.h"
UsdBaseObject::UsdBaseObject(ANARIDataType t, UsdDevice* device)
: type(t)
{
// The object will not be committed (as in, user-written write params will not be set to read params),
// but handles will be initialized and the object with its default data/refs will be written out to USD
// (but only if the prim wasn't yet written to USD before, see 'isNew' in doCommit implementations).
if(device)
device->addToCommitList(this, true);
}
void UsdBaseObject::commit(UsdDevice* device)
{
bool deferDataCommit = !device->isInitialized() || !device->getReadParams().writeAtCommit || deferCommit(device);
if(!deferDataCommit)
{
bool commitRefs = doCommitData(device);
if(commitRefs)
device->addToCommitList(this, false); // Commit refs, but no more data
}
else
device->addToCommitList(this, true); // Commit data and refs
}
| 1,008 | C++ | 33.793102 | 115 | 0.709325 |
NVIDIA-Omniverse/AnariUsdDevice/examples/anariTutorial_usd.c | // Copyright 2021 NVIDIA Corporation
// SPDX-License-Identifier: Apache-2.0
#include <errno.h>
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#ifdef _WIN32
#include <malloc.h>
#else
#include <alloca.h>
#endif
#include "anari/anari.h"
// stb_image
#include "stb_image_write.h"
#include "anariTutorial_usd_common.h"
typedef enum TestType
{
TEST_MESH,
TEST_CONES,
TEST_GLYPHS
} TestType_t;
typedef struct TestParameters
{
int writeAtCommit;
int useVertexColors;
int useTexture;
int useIndices;
int isTransparent;
TestType_t testType;
int useGlyphMesh;
} TestParameters_t;
typedef struct TexData
{
uint8_t* textureData;
uint8_t* opacityTextureData;
int textureSize[2];
} TexData_t;
float transform[16] = {
3.0f, 0.0f, 0.0f, 0.0f,
0.0f, 3.0f, 0.0f, 0.0f,
0.0f, 0.0f, 3.0f, 0.0f,
2.0f, 3.0f, 4.0f, 1.0f };
// triangle mesh data
float vertex[] = { -1.0f,
-1.0f,
3.0f,
-1.0f,
1.0f,
3.0f,
1.0f,
-1.0f,
3.0f,
0.1f,
0.1f,
0.3f };
float normal[] = { 0.0f,
0.0f,
1.0f,
0.0f,
1.0f,
0.0f,
0.0f,
1.0f,
0.0f,
1.0f,
0.0f,
0.0f
};
float color[] = { 0.0f,
0.0f,
0.9f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.0f,
0.9f,
0.0f,
1.0f };
float opacities[] = {
0.5f,
1.0f};
float texcoord[] = {
0.0f,
0.0f,
1.0f,
0.0f,
1.0f,
1.0f,
0.0f,
1.0f };
int32_t index[] = { 0, 1, 2, 2, 1, 3 };
float protoVertex[] = {-3.0f,
-1.0f,
-1.0f,
3.0f,
-1.0f,
-1.0f,
-3.0f,
1.0f,
-1.0f,
3.0f,
1.0f,
-1.0f,
-3.0f,
-1.0f,
1.0f,
3.0f,
-1.0f,
1.0f,
-3.0f,
1.0f,
1.0f,
3.0f,
1.0f,
1.0f};
float protoColor[] = {0.0f,
0.0f,
0.9f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.0f,
0.9f,
0.0f,
1.0f,
0.0f,
0.0f,
0.9f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.0f,
0.9f,
0.0f,
1.0f};
int32_t protoIndex[] = {0, 1, 2, 2, 1, 3, 2, 3, 4, 4, 3, 5, 4, 5, 6, 6, 5, 7, 6, 7, 0, 0, 7, 1};
float protoTransform[16] = {
0.75f, 0.0f, 0.0f, 0.0f,
0.0f, 1.5f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f };
float kd[] = { 0.0f, 0.0f, 1.0f };
ANARIInstance createMeshInstance(ANARIDevice dev, TestParameters_t testParams, TexData_t testData)
{
int useVertexColors = testParams.useVertexColors;
int useTexture = testParams.useTexture;
int isTransparent = testParams.isTransparent;
// create and setup mesh
ANARIGeometry mesh = anariNewGeometry(dev, "triangle");
anariSetParameter(dev, mesh, "name", ANARI_STRING, "tutorialMesh");
ANARIArray1D array = anariNewArray1D(dev, vertex, 0, 0, ANARI_FLOAT32_VEC3, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.position", ANARI_ARRAY, &array);
anariRelease(dev, array); // we are done using this handle
array = anariNewArray1D(dev, normal, 0, 0, ANARI_FLOAT32_VEC3, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.normal", ANARI_ARRAY, &array);
anariRelease(dev, array);
// Set the vertex colors
if (useVertexColors)
{
array = anariNewArray1D(dev, color, 0, 0, ANARI_FLOAT32_VEC4, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.color", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
array = anariNewArray1D(dev, texcoord, 0, 0, ANARI_FLOAT32_VEC2, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.attribute0", ANARI_ARRAY, &array);
anariRelease(dev, array);
anariSetParameter(dev, mesh, "usd::attribute0.name", ANARI_STRING, "customTexcoordName");
if(isTransparent)
{
array = anariNewArray1D(dev, opacities, 0, 0, ANARI_FLOAT32, 2);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "primitive.attribute1", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
array = anariNewArray1D(dev, index, 0, 0, ANARI_INT32_VEC3, 2);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "primitive.index", ANARI_ARRAY, &array);
anariRelease(dev, array);
anariCommitParameters(dev, mesh);
// Create a sampler
ANARISampler sampler = 0;
if(useTexture)
{
sampler = anariNewSampler(dev, "image2D");
anariSetParameter(dev, sampler, "name", ANARI_STRING, "tutorialSampler");
anariSetParameter(dev, sampler, "inAttribute", ANARI_STRING, "customTexcoordName");
anariSetParameter(dev, sampler, "wrapMode1", ANARI_STRING, wrapS);
anariSetParameter(dev, sampler, "wrapMode2", ANARI_STRING, wrapT);
array = anariNewArray2D(dev, testData.textureData, 0, 0, ANARI_UINT8_VEC3, testData.textureSize[0], testData.textureSize[1]); // Make sure this matches numTexComponents
//anariSetParameter(dev, sampler, "usd::imageUrl", ANARI_STRING, texFile);
anariSetParameter(dev, sampler, "image", ANARI_ARRAY, &array);
anariCommitParameters(dev, sampler);
anariRelease(dev, array);
}
ANARISampler opacitySampler = 0;
if(isTransparent && useTexture)
{
opacitySampler = anariNewSampler(dev, "image2D");
anariSetParameter(dev, opacitySampler, "name", ANARI_STRING, "tutorialSamplerOpacity");
anariSetParameter(dev, opacitySampler, "inAttribute", ANARI_STRING, "customTexcoordName");
anariSetParameter(dev, opacitySampler, "wrapMode1", ANARI_STRING, wrapS);
anariSetParameter(dev, opacitySampler, "wrapMode2", ANARI_STRING, wrapT);
array = anariNewArray2D(dev, testData.opacityTextureData, 0, 0, ANARI_UINT8, testData.textureSize[0], testData.textureSize[1]);
anariSetParameter(dev, opacitySampler, "image", ANARI_ARRAY, &array);
anariCommitParameters(dev, opacitySampler);
anariRelease(dev, array);
}
// Create a material
ANARIMaterial mat = anariNewMaterial(dev, "matte");
anariSetParameter(dev, mat, "name", ANARI_STRING, "tutorialMaterial");
if (useVertexColors)
anariSetParameter(dev, mat, "color", ANARI_STRING, "color");
else if(useTexture)
anariSetParameter(dev, mat, "color", ANARI_SAMPLER, &sampler);
else
anariSetParameter(dev, mat, "color", ANARI_FLOAT32_VEC3, kd);
float opacityConstant = isTransparent ? 0.65f : 1.0f;
if(isTransparent)
{
anariSetParameter(dev, mat, "alphaMode", ANARI_STRING, "blend");
if(useVertexColors)
anariSetParameter(dev, mat, "opacity", ANARI_STRING, "attribute1");
else if(useTexture)
anariSetParameter(dev, mat, "opacity", ANARI_SAMPLER, &opacitySampler);
else
anariSetParameter(dev, mat, "opacity", ANARI_FLOAT32, &opacityConstant);
}
else
{
anariSetParameter(dev, mat, "opacity", ANARI_FLOAT32, &opacityConstant);
}
int timevaryEmissive = 1; // Set emissive to timevarying (should appear in material stage under primstages/)
anariSetParameter(dev, mat, "usd::timeVarying.emissive", ANARI_BOOL, &timevaryEmissive);
anariCommitParameters(dev, mat);
anariRelease(dev, sampler);
anariRelease(dev, opacitySampler);
// put the mesh into a surface
ANARISurface surface = anariNewSurface(dev);
anariSetParameter(dev, surface, "name", ANARI_STRING, "tutorialSurface");
anariSetParameter(dev, surface, "geometry", ANARI_GEOMETRY, &mesh);
anariSetParameter(dev, surface, "material", ANARI_MATERIAL, &mat);
anariCommitParameters(dev, surface);
anariRelease(dev, mesh);
anariRelease(dev, mat);
// put the surface into a group
ANARIGroup group = anariNewGroup(dev);
anariSetParameter(dev, group, "name", ANARI_STRING, "tutorialGroup");
array = anariNewArray1D(dev, &surface, 0, 0, ANARI_SURFACE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, group, "surface", ANARI_ARRAY, &array);
anariCommitParameters(dev, group);
anariRelease(dev, surface);
anariRelease(dev, array);
// put the group into an instance (give the group a world transform)
ANARIInstance instance = anariNewInstance(dev, "transform");
anariSetParameter(dev, instance, "name", ANARI_STRING, "tutorialInstance");
anariSetParameter(dev, instance, "transform", ANARI_FLOAT32_MAT4, transform);
anariSetParameter(dev, instance, "group", ANARI_GROUP, &group);
anariRelease(dev, group);
return instance;
}
ANARIInstance createConesInstance(ANARIDevice dev, TestParameters_t testParams, GridData_t testData)
{
// create and setup geom
ANARIGeometry cones = anariNewGeometry(dev, "cone");
anariSetParameter(dev, cones, "name", ANARI_STRING, "tutorialMesh");
int sizeX = testData.gridSize[0], sizeY = testData.gridSize[1];
int numVertices = sizeX*sizeY;
// Create a snake pattern through the vertices
int numIndexTuples = sizeY*sizeX-1;
int* indices = (int*)malloc(2*(numIndexTuples+1)*sizeof(int)); // Extra space for a dummy tuple
int vertIdxTo = 0;
for(int i = 0; i < sizeX; ++i)
{
for(int j = 0; j < sizeY; ++j)
{
int vertIdxFrom = vertIdxTo;
vertIdxTo = vertIdxFrom + ((j == sizeY-1) ? sizeY : ((i%2) ? -1 : 1));
int idxAddr = 2*(sizeY*i+j);
indices[idxAddr] = vertIdxFrom;
indices[idxAddr+1] = vertIdxTo;
}
}
ANARIArray1D array = anariNewArray1D(dev, testData.gridVertex, 0, 0, ANARI_FLOAT32_VEC3, numVertices);
anariCommitParameters(dev, array);
anariSetParameter(dev, cones, "vertex.position", ANARI_ARRAY, &array);
anariRelease(dev, array); // we are done using this handle
if(testParams.useIndices)
{
array = anariNewArray1D(dev, indices, 0, 0, ANARI_INT32_VEC2, numIndexTuples);
anariCommitParameters(dev, array);
anariSetParameter(dev, cones, "primitive.index", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
// Set the vertex colors
if (testParams.useVertexColors)
{
array = anariNewArray1D(dev, testData.gridColor, 0, 0, ANARI_FLOAT32_VEC3, numVertices);
anariCommitParameters(dev, array);
anariSetParameter(dev, cones, "vertex.color", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
if(testParams.isTransparent)
{
array = anariNewArray1D(dev, testData.gridOpacity, 0, 0, ANARI_FLOAT32, numVertices);
anariCommitParameters(dev, array);
anariSetParameter(dev, cones, "vertex.attribute0", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
// Use per-primitive radii when not using indices, to test that codepath too
array = anariNewArray1D(dev, testData.gridRadius, 0, 0, ANARI_FLOAT32, testParams.useIndices ? numVertices : numVertices/2); // per-primitive is half the vertex count
anariCommitParameters(dev, array);
anariSetParameter(dev, cones, testParams.useIndices ? "vertex.radius" : "primitive.radius", ANARI_ARRAY, &array);
anariRelease(dev, array);
anariCommitParameters(dev, cones);
// Create a material
ANARIMaterial mat = anariNewMaterial(dev, "matte");
anariSetParameter(dev, mat, "name", ANARI_STRING, "tutorialMaterial");
if (testParams.useVertexColors)
anariSetParameter(dev, mat, "color", ANARI_STRING, "color");
else
anariSetParameter(dev, mat, "color", ANARI_FLOAT32_VEC3, kd);
float opacityConstant = testParams.isTransparent ? 0.65f : 1.0f;
if(testParams.isTransparent)
{
anariSetParameter(dev, mat, "alphaMode", ANARI_STRING, "blend");
if(testParams.useVertexColors)
anariSetParameter(dev, mat, "opacity", ANARI_STRING, "attribute1");
else
anariSetParameter(dev, mat, "opacity", ANARI_FLOAT32, &opacityConstant);
}
else
{
anariSetParameter(dev, mat, "opacity", ANARI_FLOAT32, &opacityConstant);
}
anariCommitParameters(dev, mat);
// put the mesh into a surface
ANARISurface surface = anariNewSurface(dev);
anariSetParameter(dev, surface, "name", ANARI_STRING, "tutorialSurface");
anariSetParameter(dev, surface, "geometry", ANARI_GEOMETRY, &cones);
anariSetParameter(dev, surface, "material", ANARI_MATERIAL, &mat);
anariCommitParameters(dev, surface);
anariRelease(dev, cones);
anariRelease(dev, mat);
// put the surface into a group
ANARIGroup group = anariNewGroup(dev);
anariSetParameter(dev, group, "name", ANARI_STRING, "tutorialGroup");
array = anariNewArray1D(dev, &surface, 0, 0, ANARI_SURFACE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, group, "surface", ANARI_ARRAY, &array);
anariCommitParameters(dev, group);
anariRelease(dev, surface);
anariRelease(dev, array);
// put the group into an instance (give the group a world transform)
ANARIInstance instance = anariNewInstance(dev, "transform");
anariSetParameter(dev, instance, "name", ANARI_STRING, "tutorialInstance");
anariSetParameter(dev, instance, "group", ANARI_GROUP, &group);
anariRelease(dev, group);
free(indices);
return instance;
}
ANARIInstance createGlyphsInstance(ANARIDevice dev, TestParameters_t testParams, GridData_t testData)
{
int sizeX = testData.gridSize[0], sizeY = testData.gridSize[1];
int numVertices = sizeX*sizeY;
ANARIArray1D array;
ANARIGeometry protoMesh;
// The prototype mesh (instanced geometry)
if(testParams.useGlyphMesh)
{
protoMesh = anariNewGeometry(dev, "triangle");
anariSetParameter(dev, protoMesh, "name", ANARI_STRING, "tutorialProtoMesh");
array = anariNewArray1D(dev, protoVertex, 0, 0, ANARI_FLOAT32_VEC3, 8);
anariCommitParameters(dev, array);
anariSetParameter(dev, protoMesh, "vertex.position", ANARI_ARRAY, &array);
anariRelease(dev, array); // we are done using this handle
if (testParams.useVertexColors)
{
array = anariNewArray1D(dev, protoColor, 0, 0, ANARI_FLOAT32_VEC4, 8);
anariCommitParameters(dev, array);
anariSetParameter(dev, protoMesh, "vertex.color", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
array = anariNewArray1D(dev, protoIndex, 0, 0, ANARI_INT32_VEC3, 8);
anariCommitParameters(dev, array);
anariSetParameter(dev, protoMesh, "primitive.index", ANARI_ARRAY, &array);
anariRelease(dev, array);
anariCommitParameters(dev, protoMesh);
}
// The glyph geometry
ANARIGeometry glyphs = anariNewGeometry(dev, "glyph");
if(testParams.useGlyphMesh)
anariSetParameter(dev, glyphs, "shapeGeometry", ANARI_GEOMETRY, &protoMesh);
else
anariSetParameter(dev, glyphs, "shapeType", ANARI_STRING, "cylinder");
anariSetParameter(dev, glyphs, "shapeTransform", ANARI_FLOAT32_MAT4, protoTransform);
if(testParams.useGlyphMesh)
anariRelease(dev, protoMesh);
array = anariNewArray1D(dev, testData.gridVertex, 0, 0, ANARI_FLOAT32_VEC3, numVertices);
anariCommitParameters(dev, array);
anariSetParameter(dev, glyphs, "vertex.position", ANARI_ARRAY, &array);
anariRelease(dev, array); // we are done using this handle
if (testParams.useVertexColors)
{
array = anariNewArray1D(dev, testData.gridColor, 0, 0, ANARI_FLOAT32_VEC3, numVertices);
anariCommitParameters(dev, array);
anariSetParameter(dev, glyphs, "vertex.color", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
array = anariNewArray1D(dev, testData.gridRadius, 0, 0, ANARI_FLOAT32, numVertices);
anariCommitParameters(dev, array);
anariSetParameter(dev, glyphs, "vertex.scale", ANARI_ARRAY, &array);
anariRelease(dev, array);
array = anariNewArray1D(dev, testData.gridOrientation, 0, 0, ANARI_FLOAT32_QUAT_IJKW, numVertices);
anariCommitParameters(dev, array);
anariSetParameter(dev, glyphs, "vertex.orientation", ANARI_ARRAY, &array);
anariRelease(dev, array);
anariCommitParameters(dev, glyphs);
// Create a material
ANARIMaterial mat = anariNewMaterial(dev, "matte");
anariSetParameter(dev, mat, "name", ANARI_STRING, "tutorialMaterial");
if (testParams.useVertexColors)
anariSetParameter(dev, mat, "color", ANARI_STRING, "color");
else
anariSetParameter(dev, mat, "color", ANARI_FLOAT32_VEC3, kd);
float opacityConstant = testParams.isTransparent ? 0.65f : 1.0f;
if(testParams.isTransparent)
{
anariSetParameter(dev, mat, "alphaMode", ANARI_STRING, "blend");
if(testParams.useVertexColors)
anariSetParameter(dev, mat, "opacity", ANARI_STRING, "attribute1");
else
anariSetParameter(dev, mat, "opacity", ANARI_FLOAT32, &opacityConstant);
}
else
{
anariSetParameter(dev, mat, "opacity", ANARI_FLOAT32, &opacityConstant);
}
anariCommitParameters(dev, mat);
// put the mesh into a surface
ANARISurface surface = anariNewSurface(dev);
anariSetParameter(dev, surface, "name", ANARI_STRING, "tutorialSurface");
anariSetParameter(dev, surface, "geometry", ANARI_GEOMETRY, &glyphs);
anariSetParameter(dev, surface, "material", ANARI_MATERIAL, &mat);
anariCommitParameters(dev, surface);
anariRelease(dev, glyphs);
anariRelease(dev, mat);
// put the surface into a group
ANARIGroup group = anariNewGroup(dev);
anariSetParameter(dev, group, "name", ANARI_STRING, "tutorialGroup");
array = anariNewArray1D(dev, &surface, 0, 0, ANARI_SURFACE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, group, "surface", ANARI_ARRAY, &array);
anariCommitParameters(dev, group);
anariRelease(dev, surface);
anariRelease(dev, array);
// put the group into an instance (give the group a world transform)
ANARIInstance instance = anariNewInstance(dev, "transform");
anariSetParameter(dev, instance, "name", ANARI_STRING, "tutorialInstance");
anariSetParameter(dev, instance, "group", ANARI_GROUP, &group);
anariRelease(dev, group);
return instance;
}
void doTest(TestParameters_t testParams)
{
printf("\n\n-------------- Starting new test iteration \n\n");
printf("Parameters: writeatcommit %d, useVertexColors %d, useTexture %d, transparent %d, geom type %s \n",
testParams.writeAtCommit, testParams.useVertexColors, testParams.useTexture, testParams.isTransparent,
((testParams.testType == TEST_MESH) ? "mesh" : ((testParams.testType == TEST_CONES) ? "cones" : "glyphs")));
stbi_flip_vertically_on_write(1);
// image sizes
int frameSize[2] = { 1024, 768 };
int textureSize[2] = { 256, 256 };
int gridSize[2] = { 100, 100 };
uint8_t* textureData = 0;
int numTexComponents = 3;
textureData = generateTexture(textureSize, numTexComponents);
uint8_t* opacityTextureData = 0;
opacityTextureData = generateTexture(textureSize, 1);
GridData_t gridData;
createSineWaveGrid(gridSize, &gridData);
TexData_t texData;
texData.textureData = textureData;
texData.opacityTextureData = opacityTextureData;
texData.textureSize[0] = textureSize[0];
texData.textureSize[1] = textureSize[1];
// camera
float cam_pos[] = { 0.f, 0.f, 0.f };
float cam_up[] = { 0.f, 1.f, 0.f };
float cam_view[] = { 0.1f, 0.f, 1.f };
printf("initialize ANARI...");
ANARILibrary lib = anariLoadLibrary(g_libraryType, statusFunc, NULL);
ANARIDevice dev = anariNewDevice(lib, "usd");
if (!dev) {
printf("\n\nERROR: could not load device '%s'\n", "usd");
return;
}
int outputBinary = 0;
int outputOmniverse = 0;
int connLogVerbosity = 0;
int outputMaterial = 1;
int outputPreviewSurface = 1;
int outputMdl = 1;
anariSetParameter(dev, dev, "usd::connection.logVerbosity", ANARI_INT32, &connLogVerbosity);
if (outputOmniverse)
{
anariSetParameter(dev, dev, "usd::serialize.hostName", ANARI_STRING, "localhost");
anariSetParameter(dev, dev, "usd::serialize.location", ANARI_STRING, "/Users/test/anari");
}
anariSetParameter(dev, dev, "usd::serialize.outputBinary", ANARI_BOOL, &outputBinary);
anariSetParameter(dev, dev, "usd::output.material", ANARI_BOOL, &outputMaterial);
anariSetParameter(dev, dev, "usd::output.previewSurfaceShader", ANARI_BOOL, &outputPreviewSurface);
anariSetParameter(dev, dev, "usd::output.mdlShader", ANARI_BOOL, &outputMdl);
anariSetParameter(dev, dev, "usd::writeAtCommit", ANARI_BOOL, &testParams.writeAtCommit);
// commit device
anariCommitParameters(dev, dev);
printf("done!\n");
printf("setting up camera...");
// create and setup camera
ANARICamera camera = anariNewCamera(dev, "perspective");
float aspect = frameSize[0] / (float)frameSize[1];
anariSetParameter(dev, camera, "aspect", ANARI_FLOAT32, &aspect);
anariSetParameter(dev, camera, "position", ANARI_FLOAT32_VEC3, cam_pos);
anariSetParameter(dev, camera, "direction", ANARI_FLOAT32_VEC3, cam_view);
anariSetParameter(dev, camera, "up", ANARI_FLOAT32_VEC3, cam_up);
anariCommitParameters(dev, camera); // commit each object to indicate mods are done
printf("done!\n");
printf("setting up scene...");
ANARIWorld world = anariNewWorld(dev);
ANARIInstance instance;
switch(testParams.testType)
{
case TEST_MESH:
instance = createMeshInstance(dev, testParams, texData);
break;
case TEST_CONES:
instance = createConesInstance(dev, testParams, gridData);
break;
case TEST_GLYPHS:
instance = createGlyphsInstance(dev, testParams, gridData);
break;
default:
break;
};
if(!instance)
return;
anariCommitParameters(dev, instance);
// create and setup light for Ambient Occlusion
ANARILight light = anariNewLight(dev, "ambient");
anariSetParameter(dev, light, "name", ANARI_STRING, "tutorialLight");
anariCommitParameters(dev, light);
ANARIArray1D array = anariNewArray1D(dev, &light, 0, 0, ANARI_LIGHT, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, world, "light", ANARI_ARRAY, &array);
anariRelease(dev, light);
anariRelease(dev, array);
// put the instance in the world
anariSetParameter(dev, world, "name", ANARI_STRING, "tutorialWorld");
array = anariNewArray1D(dev, &instance, 0, 0, ANARI_INSTANCE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, world, "instance", ANARI_ARRAY, &array);
anariRelease(dev, instance);
anariRelease(dev, array);
anariCommitParameters(dev, world);
printf("done!\n");
// print out world bounds
float worldBounds[6];
if (anariGetProperty(dev,
world,
"bounds",
ANARI_FLOAT32_BOX3,
worldBounds,
sizeof(worldBounds),
ANARI_WAIT)) {
printf("\nworld bounds: ({%f, %f, %f}, {%f, %f, %f}\n\n",
worldBounds[0],
worldBounds[1],
worldBounds[2],
worldBounds[3],
worldBounds[4],
worldBounds[5]);
}
else {
printf("\nworld bounds not returned\n\n");
}
printf("setting up renderer...");
// create renderer
ANARIRenderer renderer =
anariNewRenderer(dev, "pathtracer"); // choose path tracing renderer
// complete setup of renderer
float bgColor[4] = { 1.f, 1.f, 1.f, 1.f }; // white
anariSetParameter(dev, renderer, "backgroundColor", ANARI_FLOAT32_VEC4, bgColor);
anariCommitParameters(dev, renderer);
// create and setup frame
ANARIFrame frame = anariNewFrame(dev);
ANARIDataType colFormat = ANARI_UFIXED8_RGBA_SRGB;
ANARIDataType depthFormat = ANARI_FLOAT32;
anariSetParameter(dev, frame, "size", ANARI_UINT32_VEC2, frameSize);
anariSetParameter(dev, frame, "channel.color", ANARI_DATA_TYPE, &colFormat);
anariSetParameter(dev, frame, "channel.depth", ANARI_DATA_TYPE, &depthFormat);
anariSetParameter(dev, frame, "renderer", ANARI_RENDERER, &renderer);
anariSetParameter(dev, frame, "camera", ANARI_CAMERA, &camera);
anariSetParameter(dev, frame, "world", ANARI_WORLD, &world);
anariCommitParameters(dev, frame);
printf("rendering frame...");
// render one frame
anariRenderFrame(dev, frame);
anariFrameReady(dev, frame, ANARI_WAIT);
printf("done!\n");
printf("\ncleaning up objects...");
// final cleanups
anariRelease(dev, renderer);
anariRelease(dev, camera);
anariRelease(dev, frame);
anariRelease(dev, world);
anariRelease(dev, dev);
anariUnloadLibrary(lib);
freeTexture(textureData);
freeSineWaveGrid(&gridData);
printf("done!\n");
}
int main(int argc, const char **argv)
{
TestParameters_t testParams;
testParams.testType = TEST_MESH;
testParams.writeAtCommit = 0;
testParams.isTransparent = 0;
// Test standard flow with textures
testParams.useVertexColors = 0;
testParams.useTexture = 1;
doTest(testParams);
// With vertex colors
testParams.useVertexColors = 1;
testParams.useTexture = 0;
doTest(testParams);
// With color constant
testParams.useVertexColors = 0;
testParams.useTexture = 0;
doTest(testParams);
// Transparency
testParams.useVertexColors = 0;
testParams.useTexture = 0;
testParams.isTransparent = 1;
doTest(testParams);
// Transparency (vertex)
testParams.useVertexColors = 1;
testParams.useTexture = 0;
doTest(testParams);
// Transparency (sampler)
testParams.useVertexColors = 0;
testParams.useTexture = 1;
doTest(testParams);
// Test immediate mode writing
testParams.writeAtCommit = 1;
testParams.useVertexColors = 0;
testParams.useTexture = 1;
testParams.isTransparent = 0;
doTest(testParams);
// Cones tests
testParams.testType = TEST_CONES;
testParams.writeAtCommit = 0;
testParams.useTexture = 0;
testParams.useIndices = 0;
// With vertex colors
testParams.useVertexColors = 1;
doTest(testParams);
// With color constant
testParams.useVertexColors = 0;
doTest(testParams);
// Using indices (and vertex colors)
testParams.useIndices = 1;
testParams.useVertexColors = 1;
doTest(testParams);
// Glyphs tests
testParams.testType = TEST_GLYPHS;
testParams.writeAtCommit = 0;
testParams.useTexture = 0;
testParams.useIndices = 0;
testParams.useGlyphMesh = 0;
// With vertex colors
testParams.useVertexColors = 1;
doTest(testParams);
// With color constant
testParams.useVertexColors = 0;
doTest(testParams);
// Using indices (and vertex colors)
testParams.useGlyphMesh = 1;
doTest(testParams);
return 0;
}
| 25,558 | C | 29.069412 | 172 | 0.698294 |
NVIDIA-Omniverse/AnariUsdDevice/examples/anariTutorial_usd_recreate.c | // Copyright 2021 NVIDIA Corporation
// SPDX-License-Identifier: Apache-2.0
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#ifdef _WIN32
#include <malloc.h>
#else
#include <alloca.h>
#endif
#include "anari/anari.h"
// stb_image
#include "stb_image_write.h"
#include "anariTutorial_usd_common.h"
int main(int argc, const char **argv)
{
stbi_flip_vertically_on_write(1);
// image size
int frameSize[2] = { 1024, 768 };
int textureSize[2] = { 256, 256 };
uint8_t* textureData = 0;
int numTexComponents = 3;
textureData = generateTexture(textureSize, numTexComponents);
// camera
float cam_pos[] = {0.f, 0.f, 0.f};
float cam_up[] = {0.f, 1.f, 0.f};
float cam_view[] = {0.1f, 0.f, 1.f};
float transform[16] = {
3.0f, 0.0f, 0.0f, 0.0f,
0.0f, 3.0f, 0.0f, 0.0f,
0.0f, 0.0f, 3.0f, 0.0f,
2.0f, 3.0f, 4.0f, 1.0f };
// triangle mesh data
float vertex[] = {-1.0f,
-1.0f,
3.0f,
-1.0f,
1.0f,
3.0f,
1.0f,
-1.0f,
3.0f,
0.1f,
0.1f,
0.3f};
float normal[] = { 0.0f,
0.0f,
1.0f,
0.0f,
1.0f,
0.0f,
0.0f,
1.0f,
0.0f,
1.0f,
0.0f,
0.0f
};
float color[] = {0.0f,
0.0f,
0.9f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.0f,
0.9f,
0.0f,
1.0f};
float texcoord[] = {
0.0f,
0.0f,
1.0f,
0.0f,
1.0f,
1.0f,
0.0f,
1.0f };
float sphereSizes[] = { 0.1f,
2.0f,
0.3f,
0.05f };
int32_t index[] = {0, 1, 2, 2, 1, 3};
float kd[] = { 0.0f, 0.0f, 1.0f };
for(int anariPass = 0; anariPass < 2; ++anariPass)
{
printf("initialize ANARI...");
ANARILibrary lib = anariLoadLibrary(g_libraryType, statusFunc, NULL);
ANARIDevice dev = anariNewDevice(lib, "usd");
if (!dev) {
printf("\n\nERROR: could not load device '%s'\n", "usd");
return 1;
}
int outputBinary = 0;
int outputOmniverse = 0;
int connLogVerbosity = 0;
int outputMaterial = 1;
int createNewSession = (anariPass == 0) ? 1 : 0;
int useVertexColors = (anariPass == 0);
int useTexture = 1;
anariSetParameter(dev, dev, "usd::connection.logVerbosity", ANARI_INT32, &connLogVerbosity);
if (outputOmniverse)
{
anariSetParameter(dev, dev, "usd::serialize.hostName", ANARI_STRING, "ov-test");
anariSetParameter(dev, dev, "usd::serialize.location", ANARI_STRING, "/Users/test/anari");
}
anariSetParameter(dev, dev, "usd::serialize.outputBinary", ANARI_BOOL, &outputBinary);
anariSetParameter(dev, dev, "usd::serialize.newSession", ANARI_BOOL, &createNewSession);
anariSetParameter(dev, dev, "usd::output.material", ANARI_BOOL, &outputMaterial);
// commit device
anariCommitParameters(dev, dev);
printf("done!\n");
printf("setting up camera...");
// create and setup camera
ANARICamera camera = anariNewCamera(dev, "perspective");
float aspect = frameSize[0] / (float)frameSize[1];
anariSetParameter(dev, camera, "aspect", ANARI_FLOAT32, &aspect);
anariSetParameter(dev, camera, "position", ANARI_FLOAT32_VEC3, cam_pos);
anariSetParameter(dev, camera, "direction", ANARI_FLOAT32_VEC3, cam_view);
anariSetParameter(dev, camera, "up", ANARI_FLOAT32_VEC3, cam_up);
int deleteCam = 1;
if(anariPass == 0)
anariSetParameter(dev, camera, "usd::removePrim", ANARI_BOOL, &deleteCam);
anariCommitParameters(dev, camera); // commit each object to indicate mods are done
printf("done!\n");
printf("setting up scene...");
ANARIWorld world = anariNewWorld(dev);
// create and setup mesh
ANARIGeometry mesh = anariNewGeometry(dev, "triangle");
anariSetParameter(dev, mesh, "name", ANARI_STRING, "tutorialMesh");
ANARIArray1D array = anariNewArray1D(dev, vertex, 0, 0, ANARI_FLOAT32_VEC3, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.position", ANARI_ARRAY, &array);
anariRelease(dev, array); // we are done using this handle
array = anariNewArray1D(dev, normal, 0, 0, ANARI_FLOAT32_VEC3, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.normal", ANARI_ARRAY, &array);
anariRelease(dev, array);
// Set the vertex colors
if (useVertexColors)
{
array = anariNewArray1D(dev, color, 0, 0, ANARI_FLOAT32_VEC4, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.color", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
array = anariNewArray1D(dev, texcoord, 0, 0, ANARI_FLOAT32_VEC2, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.attribute0", ANARI_ARRAY, &array);
anariRelease(dev, array);
//array = anariNewArray1D(dev, sphereSizes, 0, 0, ANARI_FLOAT32, 4);
//anariCommitParameters(dev, array);
//anariSetParameter(dev, mesh, "vertex.radius", ANARI_ARRAY, &array);
//anariRelease(dev, array);
array = anariNewArray1D(dev, index, 0, 0, ANARI_INT32_VEC3, 2);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "primitive.index", ANARI_ARRAY, &array);
anariRelease(dev, array);
anariCommitParameters(dev, mesh);
ANARIMaterial mat;
// The second iteration should not create samplers/materials and not add it to the surface,
// so the material prim itself will remain untouched in the pre-existing stage,
// while its reference will be removed from the newly committed surface prim
if(anariPass == 0)
{
mat = anariNewMaterial(dev, "matte");
ANARISampler sampler = anariNewSampler(dev, "image2D");
// Create a sampler
anariSetParameter(dev, sampler, "name", ANARI_STRING, "tutorialSampler");
//anariSetParameter(dev, sampler, "usd::imageUrl", ANARI_STRING, texFile);
array = anariNewArray2D(dev, textureData, 0, 0, ANARI_UINT8_VEC3, textureSize[0], textureSize[1]); // Make sure this matches numTexComponents
anariSetParameter(dev, sampler, "image", ANARI_ARRAY, &array);
anariSetParameter(dev, sampler, "inAttribute", ANARI_STRING, "attribute0");
anariSetParameter(dev, sampler, "wrapMode1", ANARI_STRING, wrapS);
anariSetParameter(dev, sampler, "wrapMode2", ANARI_STRING, wrapT);
anariCommitParameters(dev, sampler);
anariRelease(dev, array);
// Create a material
anariSetParameter(dev, mat, "name", ANARI_STRING, "tutorialMaterial");
float opacity = 1.0f;
if (useVertexColors)
anariSetParameter(dev, mat, "color", ANARI_STRING, "color");
else if(useTexture)
anariSetParameter(dev, mat, "color", ANARI_SAMPLER, &sampler);
else
anariSetParameter(dev, mat, "color", ANARI_FLOAT32_VEC3, kd);
anariSetParameter(dev, mat, "opacity", ANARI_FLOAT32, &opacity);
anariCommitParameters(dev, mat);
anariRelease(dev, sampler);
}
// put the mesh into a surface
ANARISurface surface = anariNewSurface(dev);
anariSetParameter(dev, surface, "name", ANARI_STRING, "tutorialSurface");
anariSetParameter(dev, surface, "geometry", ANARI_GEOMETRY, &mesh);
if (anariPass == 0)
anariSetParameter(dev, surface, "material", ANARI_MATERIAL, &mat);
anariCommitParameters(dev, surface);
anariRelease(dev, mesh);
if (anariPass == 0)
anariRelease(dev, mat);
// put the surface into a group
ANARIGroup group = anariNewGroup(dev);
anariSetParameter(dev, group, "name", ANARI_STRING, "tutorialGroup");
array = anariNewArray1D(dev, &surface, 0, 0, ANARI_SURFACE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, group, "surface", ANARI_ARRAY, &array);
anariCommitParameters(dev, group);
anariRelease(dev, surface);
anariRelease(dev, array);
// put the group into an instance (give the group a world transform)
ANARIInstance instance = anariNewInstance(dev, "transform");
anariSetParameter(dev, instance, "name", ANARI_STRING, "tutorialInstance");
anariSetParameter(dev, instance, "transform", ANARI_FLOAT32_MAT4, transform);
anariSetParameter(dev, instance, "group", ANARI_GROUP, &group);
anariRelease(dev, group);
// create and setup light for Ambient Occlusion
ANARILight light = anariNewLight(dev, "ambient");
anariSetParameter(dev, light, "name", ANARI_STRING, "tutorialLight");
anariCommitParameters(dev, light);
array = anariNewArray1D(dev, &light, 0, 0, ANARI_LIGHT, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, world, "light", ANARI_ARRAY, &array);
anariRelease(dev, light);
anariRelease(dev, array);
anariCommitParameters(dev, instance);
// put the instance in the world
anariSetParameter(dev, world, "name", ANARI_STRING, "tutorialWorld");
array = anariNewArray1D(dev, &instance, 0, 0, ANARI_INSTANCE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, world, "instance", ANARI_ARRAY, &array);
anariRelease(dev, instance);
anariRelease(dev, array);
anariCommitParameters(dev, world);
printf("done!\n");
// print out world bounds
float worldBounds[6];
if (anariGetProperty(dev,
world,
"bounds",
ANARI_FLOAT32_BOX3,
worldBounds,
sizeof(worldBounds),
ANARI_WAIT)) {
printf("\nworld bounds: ({%f, %f, %f}, {%f, %f, %f}\n\n",
worldBounds[0],
worldBounds[1],
worldBounds[2],
worldBounds[3],
worldBounds[4],
worldBounds[5]);
}
else {
printf("\nworld bounds not returned\n\n");
}
printf("setting up renderer...");
// create renderer
ANARIRenderer renderer =
anariNewRenderer(dev, "pathtracer"); // choose path tracing renderer
// complete setup of renderer
float bgColor[4] = { 1.f, 1.f, 1.f, 1.f }; // white
anariSetParameter(dev, renderer, "backgroundColor", ANARI_FLOAT32_VEC4, bgColor);
anariCommitParameters(dev, renderer);
// create and setup frame
ANARIFrame frame = anariNewFrame(dev);
ANARIDataType colFormat = ANARI_UFIXED8_RGBA_SRGB;
ANARIDataType depthFormat = ANARI_FLOAT32;
anariSetParameter(dev, frame, "size", ANARI_UINT32_VEC2, frameSize);
anariSetParameter(dev, frame, "channel.color", ANARI_DATA_TYPE, &colFormat);
anariSetParameter(dev, frame, "channel.depth", ANARI_DATA_TYPE, &depthFormat);
anariSetParameter(dev, frame, "renderer", ANARI_RENDERER, &renderer);
anariSetParameter(dev, frame, "camera", ANARI_CAMERA, &camera);
anariSetParameter(dev, frame, "world", ANARI_WORLD, &world);
anariCommitParameters(dev, frame);
printf("rendering frame...");
// render one frame
anariRenderFrame(dev, frame);
anariFrameReady(dev, frame, ANARI_WAIT);
printf("done!\n");
printf("\ncleaning up objects...");
// final cleanups
anariRelease(dev, renderer);
anariRelease(dev, camera);
anariRelease(dev, frame);
anariRelease(dev, world);
anariRelease(dev, dev);
anariUnloadLibrary(lib);
printf("done!\n");
for(int vIdx = 0; vIdx < sizeof(vertex)/sizeof(float); ++vIdx)
{
vertex[vIdx] += 1.0f;
}
}
freeTexture(textureData);
return 0;
}
| 11,313 | C | 30.254144 | 147 | 0.644745 |
NVIDIA-Omniverse/AnariUsdDevice/examples/anariTutorial_usd.cpp | // Copyright 2021 NVIDIA Corporation
// SPDX-License-Identifier: Apache-2.0
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <array>
// anari
#define ANARI_EXTENSION_UTILITY_IMPL
#include "anari/anari_cpp.hpp"
#include "anari/anari_cpp/ext/std.h"
// stb_image
#include "stb_image_write.h"
using uvec2 = std::array<unsigned int, 2>;
using ivec3 = std::array<int, 3>;
using vec3 = std::array<float, 3>;
using vec4 = std::array<float, 4>;
using box3 = std::array<vec3, 2>;
void statusFunc(const void *userData,
ANARIDevice device,
ANARIObject source,
ANARIDataType sourceType,
ANARIStatusSeverity severity,
ANARIStatusCode code,
const char *message)
{
(void)userData;
(void)device;
(void)source;
(void)sourceType;
(void)code;
if (severity == ANARI_SEVERITY_FATAL_ERROR) {
fprintf(stderr, "[FATAL] %s\n", message);
} else if (severity == ANARI_SEVERITY_ERROR) {
fprintf(stderr, "[ERROR] %s\n", message);
} else if (severity == ANARI_SEVERITY_WARNING) {
fprintf(stderr, "[WARN ] %s\n", message);
} else if (severity == ANARI_SEVERITY_PERFORMANCE_WARNING) {
fprintf(stderr, "[PERF ] %s\n", message);
} else if (severity == ANARI_SEVERITY_INFO) {
fprintf(stderr, "[INFO ] %s\n", message);
} else if (severity == ANARI_SEVERITY_DEBUG) {
fprintf(stderr, "[DEBUG] %s\n", message);
}
}
int main(int argc, const char **argv)
{
(void)argc;
(void)argv;
stbi_flip_vertically_on_write(1);
// image size
uvec2 imgSize = {1024 /*width*/, 768 /*height*/};
// camera
vec3 cam_pos = {0.f, 0.f, 0.f};
vec3 cam_up = {0.f, 1.f, 0.f};
vec3 cam_view = {0.1f, 0.f, 1.f};
// triangle mesh array
vec3 vertex[] = {{-1.0f, -1.0f, 3.0f},
{-1.0f, 1.0f, 3.0f},
{1.0f, -1.0f, 3.0f},
{0.1f, 0.1f, 0.3f}};
vec4 color[] = {{0.9f, 0.0f, 0.0f, 1.0f},
{0.8f, 0.8f, 0.8f, 1.0f},
{0.8f, 0.8f, 0.8f, 1.0f},
{0.0f, 0.9f, 0.0f, 1.0f}};
ivec3 index[] = {{0, 1, 2}, {1, 2, 3}};
printf("initialize ANARI...");
anari::Library lib = anari::loadLibrary("usd", statusFunc);
anari::Extensions extensions =
anari::extension::getDeviceExtensionStruct(lib, "default");
if (!extensions.ANARI_KHR_GEOMETRY_TRIANGLE)
printf("WARNING: device doesn't support ANARI_KHR_GEOMETRY_TRIANGLE\n");
if (!extensions.ANARI_KHR_CAMERA_PERSPECTIVE)
printf("WARNING: device doesn't support ANARI_KHR_CAMERA_PERSPECTIVE\n");
if (!extensions.ANARI_KHR_LIGHT_DIRECTIONAL)
printf("WARNING: device doesn't support ANARI_KHR_LIGHT_DIRECTIONAL\n");
if (!extensions.ANARI_KHR_MATERIAL_MATTE)
printf("WARNING: device doesn't support ANARI_KHR_MATERIAL_MATTE\n");
ANARIDevice d = anariNewDevice(lib, "default");
printf("done!\n");
printf("setting up camera...");
// create and setup camera
auto camera = anari::newObject<anari::Camera>(d, "perspective");
anari::setParameter(
d, camera, "aspect", (float)imgSize[0] / (float)imgSize[1]);
anari::setParameter(d, camera, "position", cam_pos);
anari::setParameter(d, camera, "direction", cam_view);
anari::setParameter(d, camera, "up", cam_up);
anari::commitParameters(
d, camera); // commit objects to indicate setting parameters is done
printf("done!\n");
printf("setting up scene...");
// The world to be populated with renderable objects
auto world = anari::newObject<anari::World>(d);
// create and setup surface and mesh
auto mesh = anari::newObject<anari::Geometry>(d, "triangle");
anari::setAndReleaseParameter(
d, mesh, "vertex.position", anari::newArray1D(d, vertex, 4));
anari::setAndReleaseParameter(
d, mesh, "vertex.color", anari::newArray1D(d, color, 4));
anari::setAndReleaseParameter(
d, mesh, "primitive.index", anari::newArray1D(d, index, 2));
anari::commitParameters(d, mesh);
auto mat = anari::newObject<anari::Material>(d, "matte");
anari::setParameter(d, mat, "color", "color");
anari::commitParameters(d, mat);
// put the mesh into a surface
auto surface = anari::newObject<anari::Surface>(d);
anari::setAndReleaseParameter(d, surface, "geometry", mesh);
anari::setAndReleaseParameter(d, surface, "material", mat);
anari::commitParameters(d, surface);
// put the surface directly onto the world
anari::setAndReleaseParameter(
d, world, "surface", anari::newArray1D(d, &surface));
anari::release(d, surface);
// create and setup light
auto light = anari::newObject<anari::Light>(d, "directional");
anari::commitParameters(d, light);
anari::setAndReleaseParameter(
d, world, "light", anari::newArray1D(d, &light));
anari::release(d, light);
anari::commitParameters(d, world);
printf("done!\n");
// print out world bounds
box3 worldBounds;
if (anari::getProperty(d, world, "bounds", worldBounds, ANARI_WAIT)) {
printf("\nworld bounds: ({%f, %f, %f}, {%f, %f, %f}\n\n",
worldBounds[0][0],
worldBounds[0][1],
worldBounds[0][2],
worldBounds[1][0],
worldBounds[1][1],
worldBounds[1][2]);
} else {
printf("\nworld bounds not returned\n\n");
}
printf("setting up renderer...");
// create renderer
auto renderer = anari::newObject<anari::Renderer>(d, "default");
// objects can be named for easier identification in debug output etc.
anari::setParameter(d, renderer, "name", "MainRenderer");
printf("done!\n");
// complete setup of renderer
vec4 bgColor = {1.f, 1.f, 1.f, 1.f};
anari::setParameter(d, renderer, "backgroundColor", bgColor); // white
anari::commitParameters(d, renderer);
// create and setup frame
auto frame = anari::newObject<anari::Frame>(d);
anari::setParameter(d, frame, "size", imgSize);
anari::setParameter(d, frame, "channel.color", ANARI_UFIXED8_RGBA_SRGB);
anari::setAndReleaseParameter(d, frame, "renderer", renderer);
anari::setAndReleaseParameter(d, frame, "camera", camera);
anari::setAndReleaseParameter(d, frame, "world", world);
anari::commitParameters(d, frame);
printf("rendering out USD objects via anari::renderFrame()...");
// render one frame
anari::render(d, frame);
anari::wait(d, frame);
printf("done!\n");
printf("\ncleaning up objects...");
// final cleanups
anari::release(d, frame);
anari::release(d, d);
anari::unloadLibrary(lib);
printf("done!\n");
return 0;
}
| 6,357 | C++ | 29.27619 | 77 | 0.654554 |
NVIDIA-Omniverse/AnariUsdDevice/examples/anariTutorial_usd_common.h | // Copyright 2021 NVIDIA Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include <math.h>
#define PI 3.14159265
const char *g_libraryType = "usd";
#ifdef _WIN32
const char* texFile = "d:/models/texture.png";
#else
const char* texFile = "/home/<username>/models/texture.png"; // Point this to any png
#endif
const char* wrapS = "repeat";
const char* wrapT = "repeat";
/******************************************************************/
void statusFunc(const void *userData,
ANARIDevice device,
ANARIObject source,
ANARIDataType sourceType,
ANARIStatusSeverity severity,
ANARIStatusCode code,
const char *message)
{
(void)userData;
if (severity == ANARI_SEVERITY_FATAL_ERROR)
{
fprintf(stderr, "[FATAL] %s\n", message);
}
else if (severity == ANARI_SEVERITY_ERROR)
{
fprintf(stderr, "[ERROR] %s\n", message);
}
else if (severity == ANARI_SEVERITY_WARNING)
{
fprintf(stderr, "[WARN ] %s\n", message);
}
else if (severity == ANARI_SEVERITY_PERFORMANCE_WARNING)
{
fprintf(stderr, "[PERF ] %s\n", message);
}
else if (severity == ANARI_SEVERITY_INFO)
{
fprintf(stderr, "[INFO ] %s\n", message);
}
else if (severity == ANARI_SEVERITY_DEBUG)
{
fprintf(stderr, "[DEBUG] %s\n", message);
}
}
void writePNG(const char *fileName, ANARIDevice d, ANARIFrame frame)
{
uint32_t size[2] = {0, 0};
ANARIDataType type = ANARI_UNKNOWN;
uint32_t *pixel = (uint32_t *)anariMapFrame(d, frame, "channel.color", &size[0], &size[1], &type);
if (type == ANARI_UFIXED8_RGBA_SRGB)
stbi_write_png(fileName, size[0], size[1], 4, pixel, 4 * size[0]);
else
printf("Incorrectly returned color buffer pixel type, image not saved.\n");
anariUnmapFrame(d, frame, "channel.color");
}
uint8_t touint8t(float val)
{
return (uint8_t)floorf((val + 1.0f)*127.5f); // 0.5*255
}
uint8_t* generateTexture(int* size, int numComps)
{
uint8_t* texData = (uint8_t*)malloc(size[0]*size[1]*numComps);
for(int i = 0; i < size[0]; ++i)
{
for(int j = 0; j < size[1]; ++j)
{
int pixIdx = i*size[1]+j;
int offset = pixIdx*numComps;
float rVal = sin((float)i/size[0] * 2.0f * PI);
float gVal = cos((float)i/size[0] * 8.0f * PI);
float bVal = cos((float)j/size[1] * 20.0f * PI);
texData[offset] = touint8t(rVal);
if(numComps >= 2)
texData[offset+1] = touint8t(gVal);
if(numComps >= 3)
texData[offset+2] = touint8t(bVal);
if(numComps == 4)
texData[offset+3] = 255;
}
}
return texData;
}
void freeTexture(uint8_t* data)
{
free(data);
}
typedef struct GridData
{
float* gridVertex;
float* gridColor;
float* gridOpacity;
float* gridRadius;
float* gridOrientation;
int gridSize[2];
} GridData_t;
void createSineWaveGrid(int* size, GridData_t* gridData)
{
int baseSize = size[0]*size[1]*sizeof(float);
float* vertData = (float*)malloc(baseSize*3);
float* colorData = (float*)malloc(baseSize*3);
float* opacityData = (float*)malloc(baseSize);
float* radiusData = (float*)malloc(baseSize);
float* orientData = (float*)malloc(baseSize*4);
for(int i = 0; i < size[0]; ++i)
{
for(int j = 0; j < size[1]; ++j)
{
int vertIdx = i*size[1]+j;
int vertAddr = vertIdx*3;
float iFrac = (float)i/size[0];
float jFrac = (float)j/size[1];
// Vertex
float amp = sin((iFrac+jFrac) * 8.0f * PI) + cos(jFrac * 5.5f * PI);
vertData[vertAddr] = ((float)i)*5.0f;
vertData[vertAddr+1] = ((float)j)*5.0f;
vertData[vertAddr+2] = amp*10.0f;
// Color
float rVal = sin(iFrac * 2.0f * PI);
float gVal = cos(iFrac * 8.0f * PI);
float bVal = cos(jFrac * 20.0f * PI);
colorData[vertAddr] = rVal;
colorData[vertAddr+1] = gVal;
colorData[vertAddr+2] = bVal;
// Opacity
float opacity = 0.3f + 0.3f*(cos(iFrac * 1.0f * PI) + sin(jFrac * 7.0f * PI));
opacityData[vertIdx] = opacity;
// Radius
//spacing is 5.0, so make sure not to go over 2.5
float radius = 1.25f + 0.5f*(cos(iFrac * 5.0f * PI) + sin(jFrac * 2.0f * PI));
radiusData[vertIdx] = radius;
// Orientation
int orientAddr = vertIdx*4;
float roll = iFrac*PI*7.3, pitch = jFrac*PI*4.9, yaw = -(jFrac+0.45f)*PI*3.3;
float sinRoll = sin(roll), sinPitch = sin(pitch), sinYaw = sin(yaw);
float cosRoll = cos(roll), cosPitch = cos(pitch), cosYaw = cos(yaw);
orientData[orientAddr] = cosRoll*cosPitch*cosYaw+sinRoll*sinPitch*sinYaw;
orientData[orientAddr+1] = sinRoll*cosPitch*cosYaw-cosRoll*sinPitch*sinYaw;
orientData[orientAddr+2] = cosRoll*sinPitch*cosYaw+sinRoll*cosPitch*sinYaw;
orientData[orientAddr+3] = cosRoll*cosPitch*sinYaw-sinRoll*sinPitch*cosYaw;
}
}
gridData->gridVertex = vertData;
gridData->gridColor = colorData;
gridData->gridOpacity = opacityData;
gridData->gridRadius = radiusData;
gridData->gridOrientation = orientData;
gridData->gridSize[0] = size[0];
gridData->gridSize[1] = size[1];
}
void freeSineWaveGrid(GridData_t* gridData)
{
free(gridData->gridVertex);
free(gridData->gridColor);
free(gridData->gridOpacity);
free(gridData->gridRadius);
free(gridData->gridOrientation);
} | 5,257 | C | 26.385417 | 100 | 0.62355 |
NVIDIA-Omniverse/AnariUsdDevice/examples/anariTutorial_usd_volume.cpp | // Copyright 2021 NVIDIA Corporation
// SPDX-License-Identifier: Apache-2.0
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <array>
#include <random>
// anari
#define ANARI_EXTENSION_UTILITY_IMPL
#include "anari/anari_cpp.hpp"
#include "anari/anari_cpp/ext/std.h"
// stb_image
#include "stb_image_write.h"
using uvec2 = std::array<unsigned int, 2>;
using uvec3 = std::array<unsigned int, 3>;
using ivec3 = std::array<int, 3>;
using vec3 = std::array<float, 3>;
using vec4 = std::array<float, 4>;
using box3 = std::array<vec3, 2>;
void statusFunc(const void *userData,
ANARIDevice device,
ANARIObject source,
ANARIDataType sourceType,
ANARIStatusSeverity severity,
ANARIStatusCode code,
const char *message)
{
(void)userData;
(void)device;
(void)source;
(void)sourceType;
(void)code;
if (severity == ANARI_SEVERITY_FATAL_ERROR) {
fprintf(stderr, "[FATAL] %s\n", message);
} else if (severity == ANARI_SEVERITY_ERROR) {
fprintf(stderr, "[ERROR] %s\n", message);
} else if (severity == ANARI_SEVERITY_WARNING) {
fprintf(stderr, "[WARN ] %s\n", message);
} else if (severity == ANARI_SEVERITY_PERFORMANCE_WARNING) {
fprintf(stderr, "[PERF ] %s\n", message);
} else if (severity == ANARI_SEVERITY_INFO) {
fprintf(stderr, "[INFO ] %s\n", message);
} else if (severity == ANARI_SEVERITY_DEBUG) {
fprintf(stderr, "[DEBUG] %s\n", message);
}
}
struct ParameterInfo
{
const char* m_name;
bool m_param;
const char* m_description;
};
struct GravityVolume
{
GravityVolume(anari::Device d);
~GravityVolume();
std::vector<ParameterInfo> parameters();
anari::World world();
void commit();
private:
anari::Device m_device{nullptr};
anari::World m_world{nullptr};
};
struct Point
{
vec3 center;
float weight;
};
static std::vector<Point> generatePoints(size_t numPoints)
{
// create random number distributions for point center and weight
std::mt19937 gen(0);
std::uniform_real_distribution<float> centerDistribution(-1.f, 1.f);
std::uniform_real_distribution<float> weightDistribution(0.1f, 0.3f);
// populate the points
std::vector<Point> points(numPoints);
for (auto &p : points) {
p.center[0] = centerDistribution(gen);
p.center[1] = centerDistribution(gen);
p.center[2] = centerDistribution(gen);
p.weight = weightDistribution(gen);
}
return points;
}
static std::vector<float> generateVoxels(
const std::vector<Point> &points, ivec3 dims)
{
// get world coordinate in [-1.f, 1.f] from logical coordinates in [0,
// volumeDimension)
auto logicalToWorldCoordinates = [&](int i, int j, int k) {
vec3 result = {-1.f + float(i) / float(dims[0] - 1) * 2.f,
-1.f + float(j) / float(dims[1] - 1) * 2.f,
-1.f + float(k) / float(dims[2] - 1) * 2.f};
return result;
};
// generate voxels
std::vector<float> voxels(size_t(dims[0]) * size_t(dims[1]) * size_t(dims[2]));
for (int k = 0; k < dims[2]; k++) {
for (int j = 0; j < dims[1]; j++) {
for (int i = 0; i < dims[0]; i++) {
// index in array
size_t index = size_t(k) * size_t(dims[2]) * size_t(dims[1])
+ size_t(j) * size_t(dims[0]) + size_t(i);
// compute volume value
float value = 0.f;
for (auto &p : points) {
vec3 pointCoordinate = logicalToWorldCoordinates(i, j, k);
const float distanceSq =
std::pow(pointCoordinate[0] - p.center[0], 2.0f) +
std::pow(pointCoordinate[1] - p.center[1], 2.0f) +
std::pow(pointCoordinate[2] - p.center[2], 2.0f);
// contribution proportional to weighted inverse-square distance
// (i.e. gravity)
value += p.weight / distanceSq;
}
voxels[index] = value;
}
}
}
return voxels;
}
GravityVolume::GravityVolume(anari::Device d)
{
m_device = d;
m_world = anari::newObject<anari::World>(m_device);
}
GravityVolume::~GravityVolume()
{
anari::release(m_device, m_world);
}
std::vector<ParameterInfo> GravityVolume::parameters()
{
return {
{"withGeometry", false, "Include geometry inside the volume?"}
//
};
}
anari::World GravityVolume::world()
{
return m_world;
}
void GravityVolume::commit()
{
anari::Device d = m_device;
const bool withGeometry = false;//getParam<bool>("withGeometry", false);
const int volumeDims = 128;
const size_t numPoints = 10;
const float voxelRange[2] = {0.f, 10.f};
ivec3 volumeDims3 = {volumeDims,volumeDims,volumeDims};
vec3 fieldOrigin = {-1.f, -1.f, -1.f};
vec3 fieldSpacing = {2.f / volumeDims, 2.f / volumeDims, 2.f / volumeDims};
auto points = generatePoints(numPoints);
auto voxels = generateVoxels(points, volumeDims3);
auto field = anari::newObject<anari::SpatialField>(d, "structuredRegular");
anari::setParameter(d, field, "origin", fieldOrigin);
anari::setParameter(d, field, "spacing", fieldSpacing);
anari::setAndReleaseParameter(d,
field,
"data",
anari::newArray3D(d, voxels.data(), volumeDims, volumeDims, volumeDims));
anari::commitParameters(d, field);
auto volume = anari::newObject<anari::Volume>(d, "scivis");
anari::setAndReleaseParameter(d, volume, "value", field);
{
std::vector<vec3> colors;
std::vector<float> opacities;
colors.emplace_back(vec3{0.f, 0.f, 1.f});
colors.emplace_back(vec3{0.f, 1.f, 0.f});
colors.emplace_back(vec3{1.f, 0.f, 0.f});
opacities.emplace_back(0.f);
opacities.emplace_back(0.05f);
opacities.emplace_back(0.1f);
anari::setAndReleaseParameter(
d, volume, "color", anari::newArray1D(d, colors.data(), colors.size()));
anari::setAndReleaseParameter(d,
volume,
"opacity",
anari::newArray1D(d, opacities.data(), opacities.size()));
anariSetParameter(d, volume, "valueRange", ANARI_FLOAT32_BOX1, voxelRange);
}
anari::commitParameters(d, volume);
if (withGeometry) {
std::vector<vec3> positions(numPoints);
std::transform(
points.begin(), points.end(), positions.begin(), [](const Point &p) {
return p.center;
});
ANARIGeometry geom = anari::newObject<anari::Geometry>(d, "sphere");
anari::setAndReleaseParameter(d,
geom,
"vertex.position",
anari::newArray1D(d, positions.data(), positions.size()));
anari::setParameter(d, geom, "radius", 0.05f);
anari::commitParameters(d, geom);
auto mat = anari::newObject<anari::Material>(d, "matte");
anari::commitParameters(d, mat);
auto surface = anari::newObject<anari::Surface>(d);
anari::setAndReleaseParameter(d, surface, "geometry", geom);
anari::setAndReleaseParameter(d, surface, "material", mat);
anari::commitParameters(d, surface);
anari::setAndReleaseParameter(
d, m_world, "surface", anari::newArray1D(d, &surface));
anari::release(d, surface);
} else {
anari::unsetParameter(d, m_world, "surface");
}
anari::setAndReleaseParameter(
d, m_world, "volume", anari::newArray1D(d, &volume));
anari::release(d, volume);
// create and setup light
auto light = anari::newObject<anari::Light>(d, "directional");
anari::commitParameters(d, light);
anari::setAndReleaseParameter(
d, m_world, "light", anari::newArray1D(d, &light));
anari::release(d, light);
anari::commitParameters(d, m_world);
}
int main(int argc, const char **argv)
{
(void)argc;
(void)argv;
stbi_flip_vertically_on_write(1);
// image size
uvec2 imgSize = {1024 /*width*/, 768 /*height*/};
// camera
vec3 cam_pos = {0.f, 0.f, 0.f};
vec3 cam_up = {0.f, 1.f, 0.f};
vec3 cam_view = {0.1f, 0.f, 1.f};
// triangle mesh array
vec3 vertex[] = {{-1.0f, -1.0f, 3.0f},
{-1.0f, 1.0f, 3.0f},
{1.0f, -1.0f, 3.0f},
{0.1f, 0.1f, 0.3f}};
vec4 color[] = {{0.9f, 0.5f, 0.5f, 1.0f},
{0.8f, 0.8f, 0.8f, 1.0f},
{0.8f, 0.8f, 0.8f, 1.0f},
{0.5f, 0.9f, 0.5f, 1.0f}};
uvec3 index[] = {{0, 1, 2}, {1, 2, 3}};
printf("initialize ANARI...");
anari::Library lib = anari::loadLibrary("usd", statusFunc);
anari::Extensions extensions =
anari::extension::getDeviceExtensionStruct(lib, "default");
if (!extensions.ANARI_KHR_GEOMETRY_TRIANGLE)
printf("WARNING: device doesn't support ANARI_KHR_GEOMETRY_TRIANGLE\n");
if (!extensions.ANARI_KHR_CAMERA_PERSPECTIVE)
printf("WARNING: device doesn't support ANARI_KHR_CAMERA_PERSPECTIVE\n");
if (!extensions.ANARI_KHR_LIGHT_DIRECTIONAL)
printf("WARNING: device doesn't support ANARI_KHR_LIGHT_DIRECTIONAL\n");
if (!extensions.ANARI_KHR_MATERIAL_MATTE)
printf("WARNING: device doesn't support ANARI_KHR_MATERIAL_MATTE\n");
ANARIDevice d = anariNewDevice(lib, "default");
printf("done!\n");
printf("setting up camera...");
// create and setup camera
auto camera = anari::newObject<anari::Camera>(d, "perspective");
anari::setParameter(
d, camera, "aspect", (float)imgSize[0] / (float)imgSize[1]);
anari::setParameter(d, camera, "position", cam_pos);
anari::setParameter(d, camera, "direction", cam_view);
anari::setParameter(d, camera, "up", cam_up);
anari::commitParameters(d, camera); // commit objects to indicate setting parameters is done
printf("done!\n");
printf("setting up scene...");
GravityVolume* volumeScene = new GravityVolume(d);
volumeScene->commit();
anari::World world = volumeScene->world();
printf("setting up renderer...");
// create renderer
auto renderer = anari::newObject<anari::Renderer>(d, "default");
// objects can be named for easier identification in debug output etc.
anari::setParameter(d, renderer, "name", "MainRenderer");
printf("done!\n");
// complete setup of renderer
vec4 bgColor = {1.f, 1.f, 1.f, 1.f};
anari::setParameter(d, renderer, "backgroundColor", bgColor); // white
anari::commitParameters(d, renderer);
// create and setup frame
auto frame = anari::newObject<anari::Frame>(d);
anari::setParameter(d, frame, "size", imgSize);
anari::setParameter(d, frame, "channel.color", ANARI_UFIXED8_RGBA_SRGB);
anari::setAndReleaseParameter(d, frame, "renderer", renderer);
anari::setAndReleaseParameter(d, frame, "camera", camera);
anari::setParameter(d, frame, "world", world);
anari::commitParameters(d, frame);
printf("rendering out USD objects via anari::renderFrame()...");
// render one frame
anari::render(d, frame);
anari::wait(d, frame);
printf("done!\n");
printf("\ncleaning up objects...");
// final cleanups
anari::release(d, frame);
delete volumeScene;
anari::release(d, d);
anari::unloadLibrary(lib);
printf("done!\n");
return 0;
}
| 10,686 | C++ | 27.422872 | 94 | 0.644582 |
NVIDIA-Omniverse/AnariUsdDevice/examples/anariTutorial_usd_time.c | // Copyright 2021 NVIDIA Corporation
// SPDX-License-Identifier: Apache-2.0
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#ifdef _WIN32
#include <malloc.h>
#else
#include <alloca.h>
#endif
#include "anari/anari.h"
// stb_image
#include "stb_image_write.h"
#include "anariTutorial_usd_common.h"
int main(int argc, const char **argv)
{
stbi_flip_vertically_on_write(1);
// image size
int frameSize[2] = { 1024, 768 };
int textureSize[2] = { 256, 256 };
uint8_t* textureData = 0;
int numTexComponents = 3;
textureData = generateTexture(textureSize, numTexComponents);
// camera
float cam_pos[] = {0.f, 0.f, 0.f};
float cam_up[] = {0.f, 1.f, 0.f};
float cam_view[] = {0.1f, 0.f, 1.f};
float transform[16] = {
3.0f, 0.0f, 0.0f, 0.0f,
0.0f, 3.0f, 0.0f, 0.0f,
0.0f, 0.0f, 3.0f, 0.0f,
2.0f, 3.0f, 4.0f, 1.0f };
// triangle mesh data
float vertex[] = {-1.0f,
-1.0f,
3.0f,
-1.0f,
1.0f,
3.0f,
1.0f,
-1.0f,
3.0f,
0.1f,
0.1f,
0.3f};
float color[] = {0.0f,
0.0f,
0.9f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.0f,
0.9f,
0.0f,
1.0f};
float texcoord[] = {
0.0f,
0.0f,
1.0f,
0.0f,
1.0f,
1.0f,
0.0f,
1.0f};
float sphereSizes[] = { 0.1f,
2.0f,
0.3f,
0.05f };
int32_t index[] = {0, 1, 2, 1, 2, 3};
float protoVertex[] = {-3.0f,
-1.0f,
-1.0f,
3.0f,
-1.0f,
-1.0f,
-3.0f,
1.0f,
-1.0f,
3.0f,
1.0f,
-1.0f,
-3.0f,
-1.0f,
1.0f,
3.0f,
-1.0f,
1.0f,
-3.0f,
1.0f,
1.0f,
3.0f,
1.0f,
1.0f};
float protoColor[] = {0.0f,
0.0f,
0.9f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.0f,
0.9f,
0.0f,
1.0f,
0.0f,
0.0f,
0.9f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.8f,
0.8f,
0.8f,
1.0f,
0.0f,
0.9f,
0.0f,
1.0f};
float protoTexcoord[] = {
0.0f,
0.0f,
0.0f,
1.0f,
0.25f,
0.0f,
0.25f,
1.0f,
0.5f,
0.0f,
0.5f,
1.0f,
0.75f,
0.0f,
0.75f,
1.0f};
int32_t protoIndex[] = {0, 1, 2, 2, 1, 3, 2, 3, 4, 4, 3, 5, 4, 5, 6, 6, 5, 7, 6, 7, 0, 0, 7, 1};
float protoTransform[16] = {
0.2f, 0.0f, 0.0f, 0.0f,
0.0f, 0.2f, 0.0f, 0.0f,
0.0f, 0.0f, 0.2f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f };
float kd[] = { 0.0f, 0.0f, 1.0f };
printf("initialize ANARI...");
ANARILibrary lib = anariLoadLibrary(g_libraryType, statusFunc, NULL);
ANARIDevice dev = anariNewDevice(lib, "usd");
if (!dev) {
printf("\n\nERROR: could not load device '%s'\n", "usd");
return 1;
}
int outputBinary = 0;
int outputOmniverse = 0;
int connLogVerbosity = 0;
anariSetParameter(dev, dev, "usd::connection.logVerbosity", ANARI_INT32, &connLogVerbosity);
if (outputOmniverse)
{
anariSetParameter(dev, dev, "usd::serialize.hostName", ANARI_STRING, "ov-test");
anariSetParameter(dev, dev, "usd::serialize.location", ANARI_STRING, "/Users/test/anari");
}
anariSetParameter(dev, dev, "usd::serialize.outputBinary", ANARI_BOOL, &outputBinary);
// commit device
anariCommitParameters(dev, dev);
printf("done!\n");
printf("setting up camera...");
// create and setup camera
ANARICamera camera = anariNewCamera(dev, "perspective");
float aspect = frameSize[0] / (float)frameSize[1];
anariSetParameter(dev, camera, "aspect", ANARI_FLOAT32, &aspect);
anariSetParameter(dev, camera, "position", ANARI_FLOAT32_VEC3, cam_pos);
anariSetParameter(dev, camera, "direction", ANARI_FLOAT32_VEC3, cam_view);
anariSetParameter(dev, camera, "up", ANARI_FLOAT32_VEC3, cam_up);
anariCommitParameters(dev, camera); // commit each object to indicate mods are done
// Setup texture array
ANARIArray2D texArray = anariNewArray2D(dev, textureData, 0, 0, ANARI_UINT8_VEC3, textureSize[0], textureSize[1]); // Make sure this matches numTexComponents
printf("done!\n");
printf("setting up scene...");
double timeValues[] = { 1, 0, 2, 3, 5, 8, 4, 6, 7, 9, 10 };
double geomTimeValues[] = { 3, 0, 4, 9, 7, 8, 6, 5, 1, 2, 10 };
double matTimeValues[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int numTimeSteps = sizeof(timeValues) / sizeof(double);
int useVertexColors = 0;
int useTexture = 1;
int useUsdGeomPoints = 0;
// CREATE ALL TIMESTEPS:
for (int timeIdx = 0; timeIdx < numTimeSteps; ++timeIdx)
{
int doubleNodes = ((timeIdx % 3) == 1);
anariSetParameter(dev, dev, "usd::time", ANARI_FLOAT64, timeValues + timeIdx);
anariCommitParameters(dev, dev);
ANARIWorld world = anariNewWorld(dev);
// create and setup model and mesh
ANARIGeometry mesh = anariNewGeometry(dev, "triangle");
anariSetParameter(dev, mesh, "name", ANARI_STRING, "tutorialMesh");
float scaledVertex[12];
for (int v = 0; v < 12; ++v)
{
scaledVertex[v] = vertex[v] * (1.0f + timeIdx);
}
ANARIArray1D array = anariNewArray1D(dev, scaledVertex, 0, 0, ANARI_FLOAT32_VEC3, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.position", ANARI_ARRAY, &array);
anariRelease(dev, array); // we are done using this handle
if (useVertexColors)
{
array = anariNewArray1D(dev, color, 0, 0, ANARI_FLOAT32_VEC4, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.color", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
array = anariNewArray1D(dev, texcoord, 0, 0, ANARI_FLOAT32_VEC2, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.attribute0", ANARI_ARRAY, &array);
anariRelease(dev, array);
array = anariNewArray1D(dev, index, 0, 0, ANARI_INT32_VEC3, 2);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "primitive.index", ANARI_ARRAY, &array);
anariRelease(dev, array);
int timevaryTexcoord = 0; // Texcoords are not timeVarying (should now appear in fullscene stage)
anariSetParameter(dev, mesh, "usd::timeVarying.attribute0", ANARI_BOOL, &timevaryTexcoord);
anariSetParameter(dev, mesh, "usd::time", ANARI_FLOAT64, geomTimeValues + timeIdx);
anariCommitParameters(dev, mesh);
ANARISampler sampler = anariNewSampler(dev, "image2D");
anariSetParameter(dev, sampler, "name", ANARI_STRING, "tutorialSampler_0");
//anariSetParameter(dev, sampler, "usd::imageUrl", ANARI_STRING, texFile);
anariSetParameter(dev, sampler, "image", ANARI_ARRAY, &texArray);
anariSetParameter(dev, sampler, "inAttribute", ANARI_STRING, "attribute0");
anariSetParameter(dev, sampler, "wrapMode1", ANARI_STRING, wrapS);
anariSetParameter(dev, sampler, "wrapMode2", ANARI_STRING, wrapT);
anariCommitParameters(dev, sampler);
ANARIMaterial mat = anariNewMaterial(dev, "matte");
anariSetParameter(dev, mat, "name", ANARI_STRING, "tutorialMaterial_0");
float opacity = 1.0;// -timeIdx * 0.1f;
if (useVertexColors)
anariSetParameter(dev, mat, "color", ANARI_STRING, "color");
else if(useTexture)
anariSetParameter(dev, mat, "color", ANARI_SAMPLER, &sampler);
else
anariSetParameter(dev, mat, "color", ANARI_FLOAT32_VEC3, kd);
anariSetParameter(dev, mat, "opacity", ANARI_FLOAT32, &opacity);
anariSetParameter(dev, mat, "usd::time", ANARI_FLOAT64, matTimeValues + timeIdx);
anariCommitParameters(dev, mat);
anariRelease(dev, sampler);
// put the mesh into a model
ANARISurface surface;
surface = anariNewSurface(dev);
anariSetParameter(dev, surface, "name", ANARI_STRING, "tutorialSurface_0");
anariSetParameter(dev, surface, "geometry", ANARI_GEOMETRY, &mesh);
anariSetParameter(dev, surface, "material", ANARI_MATERIAL, &mat);
anariCommitParameters(dev, surface);
anariRelease(dev, mesh);
anariRelease(dev, mat);
// put the surface into a group
ANARIGroup group;
group = anariNewGroup(dev);
anariSetParameter(dev, group, "name", ANARI_STRING, "tutorialGroup_0");
array = anariNewArray1D(dev, &surface, 0, 0, ANARI_SURFACE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, group, "surface", ANARI_ARRAY, &array);
anariCommitParameters(dev, group);
anariRelease(dev, surface);
anariRelease(dev, array);
// put the group into an instance (give the group a world transform)
ANARIInstance instance[2];
instance[0] = anariNewInstance(dev, "transform");
anariSetParameter(dev, instance[0], "name", ANARI_STRING, "tutorialInstance_0");
anariSetParameter(dev, instance[0], "transform", ANARI_FLOAT32_MAT4, transform);
anariSetParameter(dev, instance[0], "group", ANARI_GROUP, &group);
anariRelease(dev, group);
// create and setup light for Ambient Occlusion
ANARILight light = anariNewLight(dev, "ambient");
anariSetParameter(dev, light, "name", ANARI_STRING, "tutorialLight");
anariCommitParameters(dev, light);
array = anariNewArray1D(dev, &light, 0, 0, ANARI_LIGHT, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, world, "light", ANARI_ARRAY, &array);
anariRelease(dev, light);
anariRelease(dev, array);
anariCommitParameters(dev, instance[0]);
if (doubleNodes)
{
//ANARIGeometry protoMesh = anariNewGeometry(dev, "triangle");
//anariSetParameter(dev, protoMesh, "name", ANARI_STRING, "tutorialProtoMesh");
//
//ANARIArray1D array = anariNewArray1D(dev, protoVertex, 0, 0, ANARI_FLOAT32_VEC3, 8);
//anariCommitParameters(dev, array);
//anariSetParameter(dev, protoMesh, "vertex.position", ANARI_ARRAY, &array);
//anariRelease(dev, array); // we are done using this handle
//
//if (useVertexColors)
//{
// array = anariNewArray1D(dev, protoColor, 0, 0, ANARI_FLOAT32_VEC4, 8);
// anariCommitParameters(dev, array);
// anariSetParameter(dev, protoMesh, "vertex.color", ANARI_ARRAY, &array);
// anariRelease(dev, array);
//}
//
//array = anariNewArray1D(dev, protoTexcoord, 0, 0, ANARI_FLOAT32_VEC2, 8);
//anariCommitParameters(dev, array);
//anariSetParameter(dev, protoMesh, "vertex.attribute0", ANARI_ARRAY, &array);
//anariRelease(dev, array);
//
//array = anariNewArray1D(dev, protoIndex, 0, 0, ANARI_INT32_VEC3, 8);
//anariCommitParameters(dev, array);
//anariSetParameter(dev, protoMesh, "primitive.index", ANARI_ARRAY, &array);
//anariRelease(dev, array);
//
//anariCommitParameters(dev, protoMesh);
mesh = anariNewGeometry(dev, "sphere");
anariSetParameter(dev, mesh, "name", ANARI_STRING, "tutorialPoints");
anariSetParameter(dev, mesh, "usd::useUsdGeomPoints", ANARI_BOOL, &useUsdGeomPoints);
//anariSetParameter(dev, mesh, "shapeType", ANARI_STRING, "cylinder");
//anariSetParameter(dev, mesh, "shapeGeometry", ANARI_GEOMETRY, &protoMesh);
//anariSetParameter(dev, mesh, "shapeTransform", ANARI_FLOAT32_MAT4, protoTransform);
//anariRelease(dev, protoMesh);
array = anariNewArray1D(dev, vertex, 0, 0, ANARI_FLOAT32_VEC3, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.position", ANARI_ARRAY, &array);
anariRelease(dev, array); // we are done using this handle
if (useVertexColors)
{
array = anariNewArray1D(dev, color, 0, 0, ANARI_FLOAT32_VEC4, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.color", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
array = anariNewArray1D(dev, texcoord, 0, 0, ANARI_FLOAT32_VEC2, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.attribute0", ANARI_ARRAY, &array);
anariRelease(dev, array);
array = anariNewArray1D(dev, sphereSizes, 0, 0, ANARI_FLOAT32, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.radius", ANARI_ARRAY, &array);
//anariSetParameter(dev, mesh, "vertex.scale", ANARI_ARRAY, &array);
anariRelease(dev, array);
anariSetParameter(dev, mesh, "usd::time", ANARI_FLOAT64, timeValues + timeIdx);
anariCommitParameters(dev, mesh);
sampler = anariNewSampler(dev, "image2D");
anariSetParameter(dev, sampler, "name", ANARI_STRING, "tutorialSampler_1");
//anariSetParameter(dev, sampler, "usd::imageUrl", ANARI_STRING, texFile);
anariSetParameter(dev, sampler, "image", ANARI_ARRAY, &texArray);
anariSetParameter(dev, sampler, "inAttribute", ANARI_STRING, "attribute0");
anariSetParameter(dev, sampler, "wrapMode1", ANARI_STRING, wrapS);
anariSetParameter(dev, sampler, "wrapMode2", ANARI_STRING, wrapT);
anariCommitParameters(dev, sampler);
mat = anariNewMaterial(dev, "matte");
anariSetParameter(dev, mat, "name", ANARI_STRING, "tutorialMaterial_1");
if (useVertexColors)
anariSetParameter(dev, mat, "color", ANARI_STRING, "color");
else if(useTexture)
anariSetParameter(dev, mat, "color", ANARI_SAMPLER, &sampler);
else
anariSetParameter(dev, mat, "color", ANARI_FLOAT32_VEC3, kd);
anariSetParameter(dev, mat, "usd::time", ANARI_FLOAT64, timeValues + timeIdx);
// Only colors and opacities are timevarying
int timeVaryingMetallic = 1;
int timeVaryingOpacities = 1;
anariSetParameter(dev, mat, "usd::timeVarying.metallic", ANARI_BOOL, &timeVaryingMetallic);
anariSetParameter(dev, mat, "usd::timeVarying.opacity", ANARI_BOOL, &timeVaryingOpacities);
anariCommitParameters(dev, mat);
anariRelease(dev, sampler);
// put the mesh into a model
surface = anariNewSurface(dev);
anariSetParameter(dev, surface, "name", ANARI_STRING, "tutorialSurface_1");
anariSetParameter(dev, surface, "geometry", ANARI_GEOMETRY, &mesh);
anariSetParameter(dev, surface, "material", ANARI_MATERIAL, &mat);
anariCommitParameters(dev, surface);
anariRelease(dev, mesh);
anariRelease(dev, mat);
// put the surface into a group
group = anariNewGroup(dev);
anariSetParameter(dev, group, "name", ANARI_STRING, "tutorialGroup_1");
array = anariNewArray1D(dev, &surface, 0, 0, ANARI_SURFACE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, group, "surface", ANARI_ARRAY, &array);
anariCommitParameters(dev, group);
anariRelease(dev, surface);
anariRelease(dev, array);
// put the group into an instance (give the group a world transform)
instance[1] = anariNewInstance(dev, "transform");
anariSetParameter(dev, instance[1], "name", ANARI_STRING, "tutorialInstance_1");
anariSetParameter(dev, instance[1], "transform", ANARI_FLOAT32_MAT4, transform);
anariSetParameter(dev, instance[1], "group", ANARI_GROUP, &group);
anariRelease(dev, group);
anariCommitParameters(dev, instance[1]);
}
// put the instance in the world
anariSetParameter(dev, world, "name", ANARI_STRING, "tutorialWorld");
array = anariNewArray1D(dev, instance, 0, 0, ANARI_INSTANCE, (doubleNodes ? 2 : 1));
anariCommitParameters(dev, array);
anariSetParameter(dev, world, "instance", ANARI_ARRAY, &array);
anariRelease(dev, instance[0]);
if (doubleNodes)
anariRelease(dev, instance[1]);
anariRelease(dev, array);
anariCommitParameters(dev, world);
// create renderer
ANARIRenderer renderer =
anariNewRenderer(dev, "pathtracer"); // choose path tracing renderer
// complete setup of renderer
float bgColor[4] = { 1.f, 1.f, 1.f, 1.f }; // white
anariSetParameter(dev, renderer, "backgroundColor", ANARI_FLOAT32_VEC4, bgColor);
anariCommitParameters(dev, renderer);
// create and setup frame
ANARIFrame frame = anariNewFrame(dev);
ANARIDataType colFormat = ANARI_UFIXED8_RGBA_SRGB;
ANARIDataType depthFormat = ANARI_FLOAT32;
anariSetParameter(dev, frame, "size", ANARI_UINT32_VEC2, frameSize);
anariSetParameter(dev, frame, "channel.color", ANARI_DATA_TYPE, &colFormat);
anariSetParameter(dev, frame, "channel.depth", ANARI_DATA_TYPE, &depthFormat);
anariSetParameter(dev, frame, "renderer", ANARI_RENDERER, &renderer);
anariSetParameter(dev, frame, "camera", ANARI_CAMERA, &camera);
anariSetParameter(dev, frame, "world", ANARI_WORLD, &world);
anariCommitParameters(dev, frame);
printf("rendering frame...");
// render one frame
anariRenderFrame(dev, frame);
anariFrameReady(dev, frame, ANARI_WAIT);
// final cleanups
anariRelease(dev, renderer);
anariRelease(dev, frame);
anariRelease(dev, world);
// USD-SPECIFIC RUNTIME:
// Remove unused prims in usd
// Only useful when objects are possibly removed over the whole timeline
anariSetParameter(dev, dev, "usd::garbageCollect", ANARI_VOID_POINTER, 0);
// Reset generation of unique names for next frame
// Only necessary when relying upon auto-generation of names instead of manual creation, AND not retaining ANARI objects over timesteps
anariSetParameter(dev, dev, "usd::removeUnusedNames", ANARI_VOID_POINTER, 0);
// ~
// Constant color get a bit more red every step
kd[0] = timeIdx / (float)numTimeSteps;
}
// CHANGE THE SCENE: Attach only the instance_1 to the world, so instance_0 gets removed.
for (int timeIdx = 0; timeIdx < numTimeSteps/2; ++timeIdx)
{
anariSetParameter(dev, dev, "usd::time", ANARI_FLOAT64, timeValues + timeIdx);
anariCommitParameters(dev, dev);
ANARIWorld world = anariNewWorld(dev);
ANARIArray1D array;
ANARIInstance instance;
ANARIGeometry mesh;
ANARISampler sampler;
ANARIMaterial mat;
ANARISurface surface;
ANARIGroup group;
{
mesh = anariNewGeometry(dev, "sphere");
anariSetParameter(dev, mesh, "name", ANARI_STRING, "tutorialPoints");
anariSetParameter(dev, mesh, "usd::useUsdGeomPoints", ANARI_BOOL, &useUsdGeomPoints);
ANARIArray1D array = anariNewArray1D(dev, vertex, 0, 0, ANARI_FLOAT32_VEC3, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.position", ANARI_ARRAY, &array);
anariRelease(dev, array); // we are done using this handle
if (useVertexColors)
{
array = anariNewArray1D(dev, color, 0, 0, ANARI_FLOAT32_VEC4, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.color", ANARI_ARRAY, &array);
anariRelease(dev, array);
}
array = anariNewArray1D(dev, texcoord, 0, 0, ANARI_FLOAT32_VEC2, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.attribute0", ANARI_ARRAY, &array);
anariRelease(dev, array);
array = anariNewArray1D(dev, sphereSizes, 0, 0, ANARI_FLOAT32, 4);
anariCommitParameters(dev, array);
anariSetParameter(dev, mesh, "vertex.radius", ANARI_ARRAY, &array);
//anariSetParameter(dev, mesh, "vertex.scale", ANARI_ARRAY, &array);
anariRelease(dev, array);
anariSetParameter(dev, mesh, "usd::time", ANARI_FLOAT64, timeValues + timeIdx*2); // Switch the child timestep for something else
anariCommitParameters(dev, mesh);
sampler = anariNewSampler(dev, "image2D");
anariSetParameter(dev, sampler, "name", ANARI_STRING, "tutorialSampler_1");
//anariSetParameter(dev, sampler, "usd::imageUrl", ANARI_STRING, texFile);
anariSetParameter(dev, sampler, "image", ANARI_ARRAY, &texArray);
anariSetParameter(dev, sampler, "inAttribute", ANARI_STRING, "attribute0");
anariSetParameter(dev, sampler, "wrapMode1", ANARI_STRING, wrapS);
anariSetParameter(dev, sampler, "wrapMode2", ANARI_STRING, wrapT);
anariCommitParameters(dev, sampler);
mat = anariNewMaterial(dev, "matte");
anariSetParameter(dev, mat, "name", ANARI_STRING, "tutorialMaterial_1");
if (useVertexColors)
anariSetParameter(dev, mat, "color", ANARI_STRING, "color");
else
anariSetParameter(dev, mat, "color", ANARI_FLOAT32_VEC3, kd);
anariSetParameter(dev, mat, "usd::time", ANARI_FLOAT64, timeValues + timeIdx*2);
anariCommitParameters(dev, mat);
anariRelease(dev, sampler);
// put the mesh into a model
surface = anariNewSurface(dev);
anariSetParameter(dev, surface, "name", ANARI_STRING, "tutorialSurface_1");
anariSetParameter(dev, surface, "geometry", ANARI_GEOMETRY, &mesh);
anariSetParameter(dev, surface, "material", ANARI_MATERIAL, &mat);
anariCommitParameters(dev, surface);
anariRelease(dev, mesh);
anariRelease(dev, mat);
// put the surface into a group
group = anariNewGroup(dev);
anariSetParameter(dev, group, "name", ANARI_STRING, "tutorialGroup_1");
array = anariNewArray1D(dev, &surface, 0, 0, ANARI_SURFACE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, group, "surface", ANARI_ARRAY, &array);
anariCommitParameters(dev, group);
anariRelease(dev, surface);
anariRelease(dev, array);
// put the group into an instance (give the group a world transform)
instance = anariNewInstance(dev, "transform");
anariSetParameter(dev, instance, "name", ANARI_STRING, "tutorialInstance_1");
anariSetParameter(dev, instance, "transform", ANARI_FLOAT32_MAT4, transform);
anariSetParameter(dev, instance, "group", ANARI_GROUP, &group);
anariRelease(dev, group);
anariCommitParameters(dev, instance);
}
// put the instance in the world
anariSetParameter(dev, world, "name", ANARI_STRING, "tutorialWorld");
array = anariNewArray1D(dev, &instance, 0, 0, ANARI_INSTANCE, 1);
anariCommitParameters(dev, array);
anariSetParameter(dev, world, "instance", ANARI_ARRAY, &array);
anariRelease(dev, instance);
anariRelease(dev, array);
anariCommitParameters(dev, world);
// create renderer
ANARIRenderer renderer =
anariNewRenderer(dev, "pathtracer"); // choose path tracing renderer
// complete setup of renderer
float bgColor[4] = { 1.f, 1.f, 1.f, 1.f }; // white
anariSetParameter(dev, renderer, "backgroundColor", ANARI_FLOAT32_VEC4, bgColor);
anariCommitParameters(dev, renderer);
// create and setup frame
ANARIFrame frame = anariNewFrame(dev);
ANARIDataType colFormat = ANARI_UFIXED8_RGBA_SRGB;
ANARIDataType depthFormat = ANARI_FLOAT32;
anariSetParameter(dev, frame, "size", ANARI_UINT32_VEC2, frameSize);
anariSetParameter(dev, frame, "channel.color", ANARI_DATA_TYPE, &colFormat);
anariSetParameter(dev, frame, "channel.depth", ANARI_DATA_TYPE, &depthFormat);
anariSetParameter(dev, frame, "renderer", ANARI_RENDERER, &renderer);
anariSetParameter(dev, frame, "camera", ANARI_CAMERA, &camera);
anariSetParameter(dev, frame, "world", ANARI_WORLD, &world);
anariCommitParameters(dev, frame);
printf("rendering frame...");
// render one frame
anariRenderFrame(dev, frame);
anariFrameReady(dev, frame, ANARI_WAIT);
// final cleanups
anariRelease(dev, renderer);
anariRelease(dev, frame);
anariRelease(dev, world);
// USD-SPECIFIC RUNTIME:
// Remove unused prims in usd
// Only useful when objects are possibly removed over the whole timeline
anariSetParameter(dev, dev, "usd::garbageCollect", ANARI_VOID_POINTER, 0);
// Reset generation of unique names for next frame
// Only necessary when relying upon auto-generation of names instead of manual creation, AND not retaining ANARI objects over timesteps
anariSetParameter(dev, dev, "usd::removeUnusedNames", ANARI_VOID_POINTER, 0);
// ~
}
anariRelease(dev, camera);
anariRelease(dev, texArray);
anariRelease(dev, dev);
freeTexture(textureData);
printf("done!\n");
return 0;
}
| 24,190 | C | 34.315328 | 159 | 0.653989 |
NVIDIA-Omniverse/AnariUsdDevice/superbuild/README.md | # CMake superbuild for USD ANARI Device
This CMake script runs stand alone to optionally build together any of:
- ANARIUsd Device (parent directory)
- ANARI-SDK
- USD + dependencies
The result of building this project is all the contents of the above (if built)
installed to `CMAKE_INSTALL_PREFIX`.
## Build setup
Run CMake (3.16+) on this directory from an empty build directory. This might
look like:
```bash
% mkdir _build
% cd _build
% cmake /path/to/superbuild
```
You can use tools like `ccmake` or `cmake-gui` to see what options you have. The
following variables control which items are to be built, and with which capabilities:
- `BUILD_ANARI_SDK` : build the [ANARI-SDK](https://github.com/KhronosGroup/ANARI-SDK)
- `BUILD_ANARI_USD_DEVICE`: build the root
- `BUILD_USD`: build USD + its dependencies (experimental, `OFF` by default)
- Requires preinstalled boost + tbb in `CMAKE_PREFIX_PATH`
- `USD_DEVICE_USE_OPENVDB`: Add OpenVDB output capability for ANARI volumes to the USD device
- Introduces `USE_USD_OPENVDB_BUILD`: If `ON` (default), OpenVDB is included within the USD installation
- `USD_DEVICE_USE_OMNIVERSE`: Add Omniverse output capability for generated USD output
If `BUILD_USD` or `BUILD_ANARI_SDK` are set to `OFF`, then those dependencies
will need to be found in the host environment. Use `CMAKE_PREFIX_PATH` to
point to your USD + ANARI-SDK (+ OpenVDB + Omniverse) installations respectively. Alternatively,
one can use explicit install dir variables which support `debug/` and `release/` subdirs:
- `ANARI_ROOT_DIR`: for the ANARI-SDK install directory
- `USD_ROOT_DIR`: for the USD install directory
- `OpenVDB_ROOT`: for the OpenVDB install directory (if not `USE_USD_OPENVDB_BUILD`)
- `OMNICLIENT_ROOT_DIR`: for the OmniClient install directory (typically `omni_client_library` from the connect sample deps). Requires:
- `OMNIUSDRESOLVER_ROOT_DIR`: the Omniverse Resolver install directory (typically `omni_usd_resolver` from the connect sample deps).
- `ZLIB_ROOT`: for the ZLIB install directory, required for Linux builds
For ease of use, if you want the USD and Omniverse libraries to be copied into the installation's `bin`
directory, make sure `USD_DEVICE_INSTALL_DEPS` is turned on. Otherwise, all dependency folders have to
be manually included into the path before executing the device binaries.
Lastly, the `BUILD_ANARI_USD_DEVICE` option lets you turn off building the device if you
only want to build the device's dependencies (mostly this is for developers).
## Build
Once you have set up the variables according to your situation, you can invoke the build (Linux) with:
```bash
% cmake --build .
```
or open `_build/anari_usd_superbuild.sln` (Windows) and build/install any configuration from there.
The resulting `install/` directory will contain everything that was built. You
can change the location of this install by setting `CMAKE_INSTALL_PREFIX`.
| 2,931 | Markdown | 44.107692 | 136 | 0.761515 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeCaches.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef OmniBridgeCaches_h
#define OmniBridgeCaches_h
#include <string>
#include <map>
#include <vector>
#include <memory>
#include "UsdBridgeData.h"
#include "UsdBridgeUtils_Internal.h"
struct UsdBridgePrimCache;
class UsdBridgeUsdWriter;
class UsdBridgePrimCacheManager;
typedef std::pair<std::string, UsdStageRefPtr> UsdStagePair; //Stage ptr and filename
typedef std::pair<std::pair<bool,bool>, UsdBridgePrimCache*> BoolEntryPair; // Prim exists in stage, prim exists in cache, result cache entry ptr
typedef void (*ResourceCollectFunc)(UsdBridgePrimCache*, UsdBridgeUsdWriter&);
typedef std::function<void(UsdBridgePrimCache*)> AtRemoveFunc;
typedef std::vector<UsdBridgePrimCache*> UsdBridgePrimCacheList;
typedef std::vector<SdfPath> SdfPrimPathList;
struct UsdBridgeResourceKey
{
UsdBridgeResourceKey() = default;
~UsdBridgeResourceKey() = default;
UsdBridgeResourceKey(const UsdBridgeResourceKey& key) = default;
UsdBridgeResourceKey(const char* n, double t)
{
name = n;
#ifdef TIME_BASED_CACHING
timeStep = t;
#endif
}
const char* name;
#ifdef TIME_BASED_CACHING
double timeStep;
#endif
bool operator==(const UsdBridgeResourceKey& rhs) const
{
return ( name ? (rhs.name ? (strEquals(name, rhs.name)
#ifdef TIME_BASED_CACHING
&& timeStep == rhs.timeStep
#endif
) : false ) : !rhs.name);
}
};
struct UsdBridgeRefCache
{
public:
friend class UsdBridgePrimCacheManager;
protected:
void IncRef() { ++RefCount; }
void DecRef() { --RefCount; }
unsigned int RefCount = 0;
};
struct UsdBridgePrimCache : public UsdBridgeRefCache
{
public:
friend class UsdBridgePrimCacheManager;
using ResourceContainer = std::vector<UsdBridgeResourceKey>;
//Constructors
UsdBridgePrimCache(const SdfPath& pp, const SdfPath& nm, ResourceCollectFunc cf);
UsdBridgePrimCache* GetChildCache(const TfToken& nameToken);
bool AddResourceKey(UsdBridgeResourceKey key);
SdfPath PrimPath;
SdfPath Name;
ResourceCollectFunc ResourceCollect;
std::unique_ptr<ResourceContainer> ResourceKeys; // Referenced resources
#ifdef TIME_BASED_CACHING
void SetChildVisibleAtTime(const UsdBridgePrimCache* childCache, double timeCode);
bool SetChildInvisibleAtTime(const UsdBridgePrimCache* childCache, double timeCode); // Returns whether timeCode has been removed AND the visible timeset is empty.
#endif
#ifdef VALUE_CLIP_RETIMING
static constexpr double PrimStageTimeCode = 0.0; // Prim stages are stored in ClipStages under specified time code
const UsdStagePair& GetPrimStagePair() const;
template<typename DataMemberType>
bool TimeVarBitsUpdate(DataMemberType newTimeVarBits);
UsdStagePair ManifestStage; // Holds the manifest
std::unordered_map<double, UsdStagePair> ClipStages; // Holds the stage(s) to the timevarying data
uint32_t LastTimeVaryingBits = 0; // Used to detect changes in timevarying status of parameters
#endif
#ifndef NDEBUG
std::string Debug_Name;
#endif
protected:
void AddChild(UsdBridgePrimCache* child);
void RemoveChild(UsdBridgePrimCache* child);
void RemoveUnreferencedChildTree(AtRemoveFunc atRemove);
std::vector<UsdBridgePrimCache*> Children;
#ifdef TIME_BASED_CACHING
// For each child, hold a vector of timesteps where it's visible (mimicks visibility attribute on the referencing prim)
std::vector<std::vector<double>> ChildVisibleAtTimes;
#endif
};
class UsdBridgePrimCacheManager
{
public:
typedef std::unordered_map<std::string, std::unique_ptr<UsdBridgePrimCache>> PrimCacheContainer;
typedef PrimCacheContainer::iterator PrimCacheIterator;
typedef PrimCacheContainer::const_iterator ConstPrimCacheIterator;
inline UsdBridgePrimCache* ConvertToPrimCache(const UsdBridgeHandle& handle) const
{
#ifndef NDEBUG
auto primCacheIt = FindPrimCache(handle);
assert(ValidIterator(primCacheIt));
#endif
return handle.value;
}
ConstPrimCacheIterator FindPrimCache(const std::string& name) const { return UsdPrimCaches.find(name); }
ConstPrimCacheIterator FindPrimCache(const UsdBridgeHandle& handle) const;
inline bool ValidIterator(ConstPrimCacheIterator it) const { return it != UsdPrimCaches.end(); }
ConstPrimCacheIterator CreatePrimCache(const std::string& name, const std::string& fullPath, ResourceCollectFunc collectFunc = nullptr);
void RemovePrimCache(ConstPrimCacheIterator it, UsdBridgeLogObject& LogObject);
void RemoveUnreferencedPrimCaches(AtRemoveFunc atRemove);
void AddChild(UsdBridgePrimCache* parent, UsdBridgePrimCache* child);
void RemoveChild(UsdBridgePrimCache* parent, UsdBridgePrimCache* child);
void AttachTopLevelPrim(UsdBridgePrimCache* primCache);
void DetachTopLevelPrim(UsdBridgePrimCache* primCache);
protected:
PrimCacheContainer UsdPrimCaches;
};
#ifdef VALUE_CLIP_RETIMING
template<typename DataMemberType>
bool UsdBridgePrimCache::TimeVarBitsUpdate(DataMemberType newTimeVarBits)
{
uint32_t newBits = static_cast<uint32_t>(newTimeVarBits);
bool hasChanged = (LastTimeVaryingBits != newBits);
LastTimeVaryingBits = newBits;
return hasChanged;
}
#endif
#endif | 5,182 | C | 30.035928 | 165 | 0.780973 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeUsdWriter_Material.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeUsdWriter.h"
#include "UsdBridgeUsdWriter_Common.h"
#include "stb_image_write.h"
#include <limits>
_TF_TOKENS_STRUCT_NAME(QualifiedInputTokens)::_TF_TOKENS_STRUCT_NAME(QualifiedInputTokens)()
: roughness(TfToken("inputs:roughness", TfToken::Immortal))
, opacity(TfToken("inputs:opacity", TfToken::Immortal))
, metallic(TfToken("inputs:metallic", TfToken::Immortal))
, ior(TfToken("inputs:ior", TfToken::Immortal))
, diffuseColor(TfToken("inputs:diffuseColor", TfToken::Immortal))
, specularColor(TfToken("inputs:specularColor", TfToken::Immortal))
, emissiveColor(TfToken("inputs:emissiveColor", TfToken::Immortal))
, file(TfToken("inputs:file", TfToken::Immortal))
, WrapS(TfToken("inputs:WrapS", TfToken::Immortal))
, WrapT(TfToken("inputs:WrapT", TfToken::Immortal))
, WrapR(TfToken("inputs:WrapR", TfToken::Immortal))
, varname(TfToken("inputs:varname", TfToken::Immortal))
, reflection_roughness_constant(TfToken("inputs:reflection_roughness_constant", TfToken::Immortal))
, opacity_constant(TfToken("inputs:opacity_constant", TfToken::Immortal))
, metallic_constant(TfToken("inputs:metallic_constant", TfToken::Immortal))
, ior_constant(TfToken("inputs:ior_constant"))
, diffuse_color_constant(TfToken("inputs:diffuse_color_constant", TfToken::Immortal))
, emissive_color(TfToken("inputs:emissive_color", TfToken::Immortal))
, emissive_intensity(TfToken("inputs:emissive_intensity", TfToken::Immortal))
, enable_emission(TfToken("inputs:enable_emission", TfToken::Immortal))
, name(TfToken("inputs:name", TfToken::Immortal))
, tex(TfToken("inputs:tex", TfToken::Immortal))
, wrap_u(TfToken("inputs:wrap_u", TfToken::Immortal))
, wrap_v(TfToken("inputs:wrap_v", TfToken::Immortal))
, wrap_w(TfToken("inputs:wrap_w", TfToken::Immortal))
{}
_TF_TOKENS_STRUCT_NAME(QualifiedInputTokens)::~_TF_TOKENS_STRUCT_NAME(QualifiedInputTokens)() = default;
TfStaticData<_TF_TOKENS_STRUCT_NAME(QualifiedInputTokens)> QualifiedInputTokens;
_TF_TOKENS_STRUCT_NAME(QualifiedOutputTokens)::_TF_TOKENS_STRUCT_NAME(QualifiedOutputTokens)()
: r(TfToken("outputs:r", TfToken::Immortal))
, rg(TfToken("outputs:rg", TfToken::Immortal))
, rgb(TfToken("outputs:rgb", TfToken::Immortal))
, a(TfToken("outputs:a", TfToken::Immortal))
, out(TfToken("outputs:out", TfToken::Immortal))
{}
_TF_TOKENS_STRUCT_NAME(QualifiedOutputTokens)::~_TF_TOKENS_STRUCT_NAME(QualifiedOutputTokens)() = default;
TfStaticData<_TF_TOKENS_STRUCT_NAME(QualifiedOutputTokens)> QualifiedOutputTokens;
namespace
{
struct StbWriteOutput
{
StbWriteOutput() = default;
~StbWriteOutput()
{
delete[] imageData;
}
char* imageData = nullptr;
size_t imageSize = 0;
};
void StbWriteToBuffer(void *context, void *data, int size)
{
if(data)
{
StbWriteOutput* output = reinterpret_cast<StbWriteOutput*>(context);
output->imageData = new char[size];
output->imageSize = size;
memcpy(output->imageData, data, size);
}
}
template<typename CType>
void ConvertSamplerData_Inner(const UsdBridgeSamplerData& samplerData, double normFactor, std::vector<unsigned char>& imageData)
{
int numComponents = samplerData.ImageNumComponents;
uint64_t imageDimX = samplerData.ImageDims[0];
uint64_t imageDimY = samplerData.ImageDims[1];
int64_t yStride = samplerData.ImageStride[1];
const char* samplerDataPtr = reinterpret_cast<const char*>(samplerData.Data);
int64_t baseAddr = 0;
for(uint64_t pY = 0; pY < imageDimY; ++pY, baseAddr += yStride)
{
const CType* lineAddr = reinterpret_cast<const CType*>(samplerDataPtr + baseAddr);
for(uint64_t flatX = 0; flatX < imageDimX*numComponents; ++flatX) //flattened X index
{
uint64_t dstElt = numComponents*pY*imageDimX + flatX;
double result = *(lineAddr+flatX)*normFactor;
result = (result < 0.0) ? 0.0 : ((result > 255.0) ? 255.0 : result);
imageData[dstElt] = static_cast<unsigned char>(result);
}
}
}
void ConvertSamplerDataToImage(const UsdBridgeSamplerData& samplerData, std::vector<unsigned char>& imageData)
{
UsdBridgeType flattenedType = ubutils::UsdBridgeTypeFlatten(samplerData.DataType);
int numComponents = samplerData.ImageNumComponents;
uint64_t imageDimX = samplerData.ImageDims[0];
uint64_t imageDimY = samplerData.ImageDims[1];
bool normalizedFp = (flattenedType == UsdBridgeType::FLOAT) || (flattenedType == UsdBridgeType::DOUBLE);
bool fixedPoint = (flattenedType == UsdBridgeType::USHORT) || (flattenedType == UsdBridgeType::UINT);
if(normalizedFp || fixedPoint)
{
imageData.resize(numComponents*imageDimX*imageDimY);
switch(flattenedType)
{
case UsdBridgeType::FLOAT: ConvertSamplerData_Inner<float>(samplerData, 255.0, imageData); break;
case UsdBridgeType::DOUBLE: ConvertSamplerData_Inner<double>(samplerData, 255.0, imageData); break;
case UsdBridgeType::USHORT: ConvertSamplerData_Inner<unsigned short>(samplerData,
255.0 / static_cast<double>(std::numeric_limits<unsigned short>::max()), imageData); break;
case UsdBridgeType::UINT: ConvertSamplerData_Inner<unsigned int>(samplerData,
255.0 / static_cast<double>(std::numeric_limits<unsigned int>::max()), imageData); break;
default: break;
}
}
}
template<typename DataType>
void CreateShaderInput(UsdShadeShader& shader, const TimeEvaluator<DataType>* timeEval, typename DataType::DataMemberId dataMemberId,
const TfToken& inputToken, const TfToken& qualifiedInputToken, const SdfValueTypeName& valueType)
{
if(!timeEval || timeEval->IsTimeVarying(dataMemberId))
shader.CreateInput(inputToken, valueType);
else
shader.GetPrim().RemoveProperty(qualifiedInputToken);
}
template<bool PreviewSurface>
void CreateMaterialShaderInput(UsdShadeShader& shader, const TimeEvaluator<UsdBridgeMaterialData>* timeEval,
typename UsdBridgeMaterialData::DataMemberId dataMemberId, const SdfValueTypeName& valueType)
{
const TfToken& inputToken = GetMaterialShaderInputToken<PreviewSurface>(dataMemberId);
const TfToken& qualifiedInputToken = GetMaterialShaderInputQualifiedToken<PreviewSurface>(dataMemberId);
CreateShaderInput(shader, timeEval, dataMemberId, inputToken, qualifiedInputToken, valueType);
}
template<typename ValueType, typename DataType>
void SetShaderInput(UsdShadeShader& uniformShadPrim, UsdShadeShader& timeVarShadPrim, const TimeEvaluator<DataType>& timeEval,
const TfToken& inputToken, typename DataType::DataMemberId dataMemberId, ValueType value)
{
using DMI = typename DataType::DataMemberId;
bool timeVaryingUpdate = timeEval.IsTimeVarying(dataMemberId);
UsdShadeInput timeVarInput, uniformInput;
UsdAttribute uniformAttrib, timeVarAttrib;
if(timeVarShadPrim) // Allow for non-existing prims (based on timeVaryingUpdate)
{
timeVarInput = timeVarShadPrim.GetInput(inputToken);
assert(timeVarInput);
timeVarAttrib = timeVarInput.GetAttr();
}
if(uniformShadPrim)
{
uniformInput = uniformShadPrim.GetInput(inputToken);
assert(uniformInput);
uniformAttrib = uniformInput.GetAttr();
}
// Clear the attributes that are not set (based on timeVaryingUpdate)
ClearUsdAttributes(uniformAttrib, timeVarAttrib, timeVaryingUpdate);
// Set the input that requires an update
SET_TIMEVARYING_ATTRIB(timeVaryingUpdate, timeVarInput, uniformInput, value);
}
UsdShadeOutput InitializeMdlGraphNode(UsdShadeShader& graphNode, const TfToken& assetSubIdent, const SdfValueTypeName& returnType,
const char* sourceAssetPath = constring::mdlSupportAssetName)
{
graphNode.CreateImplementationSourceAttr(VtValue(UsdBridgeTokens->sourceAsset));
graphNode.SetSourceAsset(SdfAssetPath(sourceAssetPath), UsdBridgeTokens->mdl);
graphNode.SetSourceAssetSubIdentifier(assetSubIdent, UsdBridgeTokens->mdl);
return graphNode.CreateOutput(UsdBridgeTokens->out, returnType);
}
struct ShadeGraphTypeConversionNodeContext
{
ShadeGraphTypeConversionNodeContext(UsdStageRefPtr sceneStage,
const SdfPath& matPrimPath,
const char* connectionIdentifier)
: SceneStage(sceneStage)
, MatPrimPath(matPrimPath)
, ConnectionIdentifier(connectionIdentifier)
{
}
// sourceOutput is set to the new node's output upon return
UsdShadeShader CreateAndConnectMdlTypeConversionNode(UsdShadeOutput& sourceOutput, const char* primNamePf, const TfToken& assetSubIdent,
const SdfValueTypeName& inType, const SdfValueTypeName& outType, const char* sourceAssetPath = constring::mdlSupportAssetName) const
{
SdfPath nodePrimPath = this->MatPrimPath.AppendPath(SdfPath(std::string(this->ConnectionIdentifier)+primNamePf));
UsdShadeShader conversionNode = UsdShadeShader::Get(this->SceneStage, nodePrimPath);
UsdShadeOutput nodeOut;
if(!conversionNode)
{
conversionNode = UsdShadeShader::Define(this->SceneStage, nodePrimPath);
assert(conversionNode);
nodeOut = InitializeMdlGraphNode(conversionNode, assetSubIdent, outType, sourceAssetPath);
conversionNode.CreateInput(UsdBridgeTokens->a, inType);
}
else
nodeOut = conversionNode.GetOutput(UsdBridgeTokens->out);
conversionNode.GetInput(UsdBridgeTokens->a).ConnectToSource(sourceOutput);
sourceOutput = nodeOut;
return conversionNode;
}
void InsertMdlShaderTypeConversionNodes(const UsdShadeInput& shadeInput, UsdShadeOutput& nodeOutput) const
{
if(shadeInput.GetTypeName() == SdfValueTypeNames->Color3f)
{
// Introduce new nodes until the type matches color3f.
// Otherwise, just connect any random output type to the input.
if(nodeOutput.GetTypeName() == SdfValueTypeNames->Float4)
{
// Changes nodeOutput to the output of the new node
CreateAndConnectMdlTypeConversionNode(nodeOutput, constring::mdlGraphXYZPrimPf,
UsdBridgeTokens->xyz, SdfValueTypeNames->Float4, SdfValueTypeNames->Float3, constring::mdlAuxAssetName);
}
if(nodeOutput.GetTypeName() == SdfValueTypeNames->Float3)
{
CreateAndConnectMdlTypeConversionNode(nodeOutput, constring::mdlGraphColorPrimPf,
UsdBridgeTokens->construct_color, SdfValueTypeNames->Float3, SdfValueTypeNames->Color3f, constring::mdlAuxAssetName);
}
}
if(shadeInput.GetTypeName() == SdfValueTypeNames->Float)
{
const char* componentPrimPf = constring::mdlGraphWPrimPf;
TfToken componentAssetIdent = (nodeOutput.GetTypeName() == SdfValueTypeNames->Float4) ? UsdBridgeTokens->w : UsdBridgeTokens->x;
switch(ChannelSelector)
{
case 0: componentPrimPf = constring::mdlGraphXPrimPf; componentAssetIdent = UsdBridgeTokens->x; break;
case 1: componentPrimPf = constring::mdlGraphYPrimPf; componentAssetIdent = UsdBridgeTokens->y; break;
case 2: componentPrimPf = constring::mdlGraphZPrimPf; componentAssetIdent = UsdBridgeTokens->z; break;
default: break;
}
if(nodeOutput.GetTypeName() == SdfValueTypeNames->Float4)
{
CreateAndConnectMdlTypeConversionNode(nodeOutput, componentPrimPf,
componentAssetIdent, SdfValueTypeNames->Float4, SdfValueTypeNames->Float, constring::mdlAuxAssetName);
}
else if(nodeOutput.GetTypeName() == SdfValueTypeNames->Float3)
{
CreateAndConnectMdlTypeConversionNode(nodeOutput, componentPrimPf,
componentAssetIdent, SdfValueTypeNames->Float3, SdfValueTypeNames->Float, constring::mdlAuxAssetName);
}
}
}
UsdStageRefPtr SceneStage;
const SdfPath& MatPrimPath;
const char* ConnectionIdentifier = nullptr;
// Optional
int ChannelSelector = 0;
};
void InitializePsShaderUniform(UsdShadeShader& shader)
{
shader.CreateIdAttr(VtValue(UsdBridgeTokens->UsdPreviewSurface));
shader.CreateInput(UsdBridgeTokens->useSpecularWorkflow, SdfValueTypeNames->Int).Set(0);
}
void InitializePsShaderTimeVar(UsdShadeShader& shader, const TimeEvaluator<UsdBridgeMaterialData>* timeEval = nullptr)
{
typedef UsdBridgeMaterialData::DataMemberId DMI;
CreateMaterialShaderInput<true>(shader, timeEval, DMI::DIFFUSE, SdfValueTypeNames->Color3f);
CreateMaterialShaderInput<true>(shader, timeEval, DMI::EMISSIVECOLOR, SdfValueTypeNames->Color3f);
CreateMaterialShaderInput<true>(shader, timeEval, DMI::ROUGHNESS, SdfValueTypeNames->Float);
CreateMaterialShaderInput<true>(shader, timeEval, DMI::OPACITY, SdfValueTypeNames->Float);
CreateMaterialShaderInput<true>(shader, timeEval, DMI::METALLIC, SdfValueTypeNames->Float);
CreateMaterialShaderInput<true>(shader, timeEval, DMI::IOR, SdfValueTypeNames->Float);
CreateShaderInput(shader, timeEval, DMI::OPACITY, UsdBridgeTokens->opacityThreshold, QualifiedInputTokens->opacityThreshold, SdfValueTypeNames->Float);
}
void InitializeMdlShaderUniform(UsdShadeShader& shader)
{
typedef UsdBridgeMaterialData::DataMemberId DMI;
shader.CreateImplementationSourceAttr(VtValue(UsdBridgeTokens->sourceAsset));
shader.SetSourceAsset(SdfAssetPath(constring::mdlShaderAssetName), UsdBridgeTokens->mdl);
shader.SetSourceAssetSubIdentifier(UsdBridgeTokens->OmniPBR, UsdBridgeTokens->mdl);
shader.CreateInput(GetMaterialShaderInputToken<false>(DMI::OPACITY), SdfValueTypeNames->Float); // Opacity is handled by the opacitymul node
}
void InitializeMdlShaderTimeVar(UsdShadeShader& shader, const TimeEvaluator<UsdBridgeMaterialData>* timeEval = nullptr)
{
typedef UsdBridgeMaterialData::DataMemberId DMI;
CreateMaterialShaderInput<false>(shader, timeEval, DMI::DIFFUSE, SdfValueTypeNames->Color3f);
CreateMaterialShaderInput<false>(shader, timeEval, DMI::EMISSIVECOLOR, SdfValueTypeNames->Color3f);
CreateMaterialShaderInput<false>(shader, timeEval, DMI::EMISSIVEINTENSITY, SdfValueTypeNames->Float);
CreateMaterialShaderInput<false>(shader, timeEval, DMI::ROUGHNESS, SdfValueTypeNames->Float);
CreateMaterialShaderInput<false>(shader, timeEval, DMI::METALLIC, SdfValueTypeNames->Float);
//CreateMaterialShaderInput<false>(shader, timeEval, DMI::IOR, SdfValueTypeNames->Float); // not supported in OmniPBR.mdl
CreateShaderInput(shader, timeEval, DMI::OPACITY, UsdBridgeTokens->enable_opacity, QualifiedInputTokens->enable_opacity, SdfValueTypeNames->Bool);
CreateShaderInput(shader, timeEval, DMI::OPACITY, UsdBridgeTokens->opacity_threshold, QualifiedInputTokens->opacity_threshold, SdfValueTypeNames->Float);
CreateShaderInput(shader, timeEval, DMI::EMISSIVEINTENSITY, UsdBridgeTokens->enable_emission, QualifiedInputTokens->enable_emission, SdfValueTypeNames->Bool);
}
UsdShadeOutput InitializePsAttributeReaderUniform(UsdShadeShader& attributeReader, const TfToken& readerId, const SdfValueTypeName& returnType)
{
attributeReader.CreateIdAttr(VtValue(readerId));
// Input name and output type are tightly coupled; output type cannot be timevarying, so neither can the name
attributeReader.CreateInput(UsdBridgeTokens->varname, SdfValueTypeNames->Token);
return attributeReader.CreateOutput(UsdBridgeTokens->result, returnType);
}
template<typename DataType>
void InitializePsAttributeReaderTimeVar(UsdShadeShader& attributeReader, typename DataType::DataMemberId dataMemberId, const TimeEvaluator<DataType>* timeEval)
{
//CreateShaderInput(attributeReader, timeEval, dataMemberId, UsdBridgeTokens->varname, QualifiedInputTokens->varname, SdfValueTypeNames->Token);
}
UsdShadeOutput InitializeMdlAttributeReaderUniform(UsdShadeShader& attributeReader, const TfToken& readerId, const SdfValueTypeName& returnType)
{
attributeReader.CreateImplementationSourceAttr(VtValue(UsdBridgeTokens->sourceAsset));
attributeReader.SetSourceAsset(SdfAssetPath(constring::mdlSupportAssetName), UsdBridgeTokens->mdl);
attributeReader.SetSourceAssetSubIdentifier(readerId, UsdBridgeTokens->mdl);
// Input name and output type are tightly coupled; output type cannot be timevarying, so neither can the name
attributeReader.CreateInput(UsdBridgeTokens->name, SdfValueTypeNames->String);
return attributeReader.CreateOutput(UsdBridgeTokens->out, returnType);
}
template<typename DataType>
void InitializeMdlAttributeReaderTimeVar(UsdShadeShader& attributeReader, typename DataType::DataMemberId dataMemberId, const TimeEvaluator<DataType>* timeEval)
{
//CreateShaderInput(attributeReader, timeEval, dataMemberId, UsdBridgeTokens->name, QualifiedInputTokens->name, SdfValueTypeNames->String);
}
void InitializePsSamplerUniform(UsdShadeShader& sampler, const SdfValueTypeName& coordType, const UsdShadeOutput& tcrOutput)
{
sampler.CreateIdAttr(VtValue(UsdBridgeTokens->UsdUVTexture));
sampler.CreateOutput(UsdBridgeTokens->rgb, SdfValueTypeNames->Float3); // Input images with less components are automatically expanded, see usd docs
sampler.CreateOutput(UsdBridgeTokens->a, SdfValueTypeNames->Float);
sampler.CreateInput(UsdBridgeTokens->fallback, SdfValueTypeNames->Float4).Set(GfVec4f(1.0f, 0.0f, 0.0f, 1.0f));
// Bind the texcoord reader's output to the sampler's st input
sampler.CreateInput(UsdBridgeTokens->st, coordType).ConnectToSource(tcrOutput);
}
void InitializePsSamplerTimeVar(UsdShadeShader& sampler, UsdBridgeSamplerData::SamplerType type, const TimeEvaluator<UsdBridgeSamplerData>* timeEval = nullptr)
{
typedef UsdBridgeSamplerData::DataMemberId DMI;
CreateShaderInput(sampler, timeEval, DMI::DATA, UsdBridgeTokens->file, QualifiedInputTokens->file, SdfValueTypeNames->Asset);
CreateShaderInput(sampler, timeEval, DMI::WRAPS, UsdBridgeTokens->WrapS, QualifiedInputTokens->WrapS, SdfValueTypeNames->Token);
if((uint32_t)type >= (uint32_t)UsdBridgeSamplerData::SamplerType::SAMPLER_2D)
CreateShaderInput(sampler, timeEval, DMI::WRAPT, UsdBridgeTokens->WrapT, QualifiedInputTokens->WrapT, SdfValueTypeNames->Token);
if((uint32_t)type >= (uint32_t)UsdBridgeSamplerData::SamplerType::SAMPLER_3D)
CreateShaderInput(sampler, timeEval, DMI::WRAPR, UsdBridgeTokens->WrapR, QualifiedInputTokens->WrapR, SdfValueTypeNames->Token);
}
void InitializeMdlSamplerUniform(UsdShadeShader& sampler, const SdfValueTypeName& coordType, const UsdShadeOutput& tcrOutput)
{
sampler.CreateImplementationSourceAttr(VtValue(UsdBridgeTokens->sourceAsset));
sampler.SetSourceAsset(SdfAssetPath(constring::mdlSupportAssetName), UsdBridgeTokens->mdl);
sampler.SetSourceAssetSubIdentifier(UsdBridgeTokens->lookup_float4, UsdBridgeTokens->mdl);
sampler.CreateOutput(UsdBridgeTokens->out, SdfValueTypeNames->Float4);
// Bind the texcoord reader's output to the sampler's coord input
sampler.CreateInput(UsdBridgeTokens->coord, coordType).ConnectToSource(tcrOutput);
}
void InitializeMdlSamplerTimeVar(UsdShadeShader& sampler, UsdBridgeSamplerData::SamplerType type, const TimeEvaluator<UsdBridgeSamplerData>* timeEval = nullptr)
{
typedef UsdBridgeSamplerData::DataMemberId DMI;
CreateShaderInput(sampler, timeEval, DMI::DATA, UsdBridgeTokens->tex, QualifiedInputTokens->tex, SdfValueTypeNames->Asset);
CreateShaderInput(sampler, timeEval, DMI::WRAPS, UsdBridgeTokens->wrap_u, QualifiedInputTokens->wrap_u, SdfValueTypeNames->Int);
if((uint32_t)type >= (uint32_t)UsdBridgeSamplerData::SamplerType::SAMPLER_2D)
CreateShaderInput(sampler, timeEval, DMI::WRAPT, UsdBridgeTokens->wrap_v, QualifiedInputTokens->wrap_v, SdfValueTypeNames->Int);
if((uint32_t)type >= (uint32_t)UsdBridgeSamplerData::SamplerType::SAMPLER_3D)
CreateShaderInput(sampler, timeEval, DMI::WRAPR, UsdBridgeTokens->wrap_w, QualifiedInputTokens->wrap_w, SdfValueTypeNames->Int);
}
UsdShadeOutput InitializePsShader(UsdStageRefPtr shaderStage, const SdfPath& matPrimPath, bool uniformPrim
, const TimeEvaluator<UsdBridgeMaterialData>* timeEval = nullptr)
{
// Create the shader
SdfPath shadPrimPath = matPrimPath.AppendPath(SdfPath(constring::psShaderPrimPf));
UsdShadeShader shader = GetOrDefinePrim<UsdShadeShader>(shaderStage, shadPrimPath);
assert(shader);
if (uniformPrim)
{
InitializePsShaderUniform(shader);
}
InitializePsShaderTimeVar(shader, timeEval);
if(uniformPrim)
return shader.CreateOutput(UsdBridgeTokens->surface, SdfValueTypeNames->Token);
else
return UsdShadeOutput();
}
UsdShadeOutput InitializeMdlShader(UsdStageRefPtr shaderStage, const SdfPath& matPrimPath, bool uniformPrim
, const TimeEvaluator<UsdBridgeMaterialData>* timeEval = nullptr)
{
typedef UsdBridgeMaterialData::DataMemberId DMI;
// Create the shader
SdfPath shadPrimPath = matPrimPath.AppendPath(SdfPath(constring::mdlShaderPrimPf));
UsdShadeShader shader = GetOrDefinePrim<UsdShadeShader>(shaderStage, shadPrimPath);
assert(shader);
// Create a mul shader node (for connection to opacity)
SdfPath shadPrimPath_opmul = matPrimPath.AppendPath(SdfPath(constring::mdlOpacityMulPrimPf));
UsdShadeShader opacityMul = GetOrDefinePrim<UsdShadeShader>(shaderStage, shadPrimPath_opmul);
assert(opacityMul);
UsdShadeOutput opacityMulOut;
if(uniformPrim)
{
opacityMulOut = InitializeMdlGraphNode(opacityMul, UsdBridgeTokens->mul_float, SdfValueTypeNames->Float);
opacityMul.CreateInput(UsdBridgeTokens->a, SdfValueTypeNames->Float); // Input a is either connected (to sampler/vc opacity) or 1.0, so never timevarying
InitializeMdlShaderUniform(shader);
}
CreateShaderInput(opacityMul, timeEval, DMI::OPACITY, UsdBridgeTokens->b, QualifiedInputTokens->b, SdfValueTypeNames->Float);
InitializeMdlShaderTimeVar(shader, timeEval);
// Connect the opacity mul node to the shader
if(uniformPrim)
{
shader.GetInput(GetMaterialShaderInputToken<false>(DMI::OPACITY)).ConnectToSource(opacityMulOut);
}
if(uniformPrim)
return shader.CreateOutput(UsdBridgeTokens->out, SdfValueTypeNames->Token);
else
return UsdShadeOutput();
}
void BindShaderToMaterial(const UsdShadeMaterial& matPrim, const UsdShadeOutput& shadOut, TfToken* renderContext)
{
// Bind the material to the shader reference subprim.
if(renderContext)
matPrim.CreateSurfaceOutput(*renderContext).ConnectToSource(shadOut);
else
matPrim.CreateSurfaceOutput().ConnectToSource(shadOut);
}
UsdShadeMaterial InitializeUsdMaterial_Impl(UsdStageRefPtr materialStage, const SdfPath& matPrimPath, bool uniformPrim, const UsdBridgeSettings& settings,
const TimeEvaluator<UsdBridgeMaterialData>* timeEval = nullptr)
{
// Create the material
UsdShadeMaterial matPrim = GetOrDefinePrim<UsdShadeMaterial>(materialStage, matPrimPath);
assert(matPrim);
if(settings.EnablePreviewSurfaceShader)
{
// Create a shader
UsdShadeOutput shaderOutput = InitializePsShader(materialStage, matPrimPath, uniformPrim, timeEval);
if(uniformPrim)
BindShaderToMaterial(matPrim, shaderOutput, nullptr);
}
if(settings.EnableMdlShader)
{
// Create an mdl shader
UsdShadeOutput shaderOutput = InitializeMdlShader(materialStage, matPrimPath, uniformPrim, timeEval);
if(uniformPrim)
BindShaderToMaterial(matPrim, shaderOutput, &UsdBridgeTokens->mdl);
}
return matPrim;
}
UsdPrim InitializePsSampler_Impl(UsdStageRefPtr samplerStage, const SdfPath& samplerPrimPath, UsdBridgeSamplerData::SamplerType type, bool uniformPrim,
const TimeEvaluator<UsdBridgeSamplerData>* timeEval = nullptr)
{
typedef UsdBridgeSamplerData::DataMemberId DMI;
UsdShadeShader sampler = GetOrDefinePrim<UsdShadeShader>(samplerStage, samplerPrimPath);
assert(sampler);
if(uniformPrim)
{
SdfPath texCoordReaderPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::texCoordReaderPrimPf));
UsdShadeShader texCoordReader = UsdShadeShader::Define(samplerStage, texCoordReaderPrimPath);
assert(texCoordReader);
// USD does not yet allow for anything but 2D coords, but let's try anyway
TfToken idAttrib;
SdfValueTypeName valueType;
if(type == UsdBridgeSamplerData::SamplerType::SAMPLER_1D)
{
idAttrib = UsdBridgeTokens->PrimVarReader_Float;
valueType = SdfValueTypeNames->Float;
}
else if (type == UsdBridgeSamplerData::SamplerType::SAMPLER_2D)
{
idAttrib = UsdBridgeTokens->PrimVarReader_Float2;
valueType = SdfValueTypeNames->Float2;
}
else
{
idAttrib = UsdBridgeTokens->PrimVarReader_Float3;
valueType = SdfValueTypeNames->Float3;
}
UsdShadeOutput tcrOutput = InitializePsAttributeReaderUniform(texCoordReader, idAttrib, valueType);
InitializePsSamplerUniform(sampler, valueType, tcrOutput);
}
//InitializePsAttributeReaderTimeVar(texCoordReader, DMI::INATTRIBUTE, timeEval); // timevar attribute reader disabled
InitializePsSamplerTimeVar(sampler, type, timeEval);
return sampler.GetPrim();
}
UsdPrim InitializeMdlSampler_Impl(UsdStageRefPtr samplerStage, const SdfPath& samplerPrimPath, UsdBridgeSamplerData::SamplerType type, bool uniformPrim,
const TimeEvaluator<UsdBridgeSamplerData>* timeEval = nullptr)
{
typedef UsdBridgeSamplerData::DataMemberId DMI;
UsdShadeShader sampler = GetOrDefinePrim<UsdShadeShader>(samplerStage, samplerPrimPath);
assert(sampler);
if(uniformPrim)
{
SdfPath texCoordReaderPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::texCoordReaderPrimPf));
UsdShadeShader texCoordReader = UsdShadeShader::Define(samplerStage, texCoordReaderPrimPath);
assert(texCoordReader);
// USD does not yet allow for anything but 2D coords, but let's try anyway
TfToken idAttrib;
SdfValueTypeName valueType;
if(type == UsdBridgeSamplerData::SamplerType::SAMPLER_1D)
{
idAttrib = UsdBridgeTokens->data_lookup_float2; // Currently, there is no 1D lookup
valueType = SdfValueTypeNames->Float2;
}
else if (type == UsdBridgeSamplerData::SamplerType::SAMPLER_2D)
{
idAttrib = UsdBridgeTokens->data_lookup_float2;
valueType = SdfValueTypeNames->Float2;
}
else
{
idAttrib = UsdBridgeTokens->data_lookup_float3;
valueType = SdfValueTypeNames->Float3;
}
UsdShadeOutput tcrOutput = InitializeMdlAttributeReaderUniform(texCoordReader, idAttrib, valueType);
InitializeMdlSamplerUniform(sampler, valueType, tcrOutput);
}
//InitializeMdlAttributeReaderTimeVar(texCoordReader, DMI::INATTRIBUTE, timeEval); // timevar attribute reader disabled
InitializeMdlSamplerTimeVar(sampler, type, timeEval);
if(uniformPrim)
{
sampler.GetInput(UsdBridgeTokens->tex).GetAttr().SetMetadata(UsdBridgeTokens->colorSpace, VtValue("sRGB"));
}
return sampler.GetPrim();
}
void InitializeSampler_Impl(UsdStageRefPtr samplerStage, const SdfPath& samplerPrimPath, UsdBridgeSamplerData::SamplerType type, bool uniformPrim,
const UsdBridgeSettings& settings, const TimeEvaluator<UsdBridgeSamplerData>* timeEval = nullptr)
{
if(settings.EnablePreviewSurfaceShader)
{
SdfPath usdSamplerPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::psSamplerPrimPf));
InitializePsSampler_Impl(samplerStage, usdSamplerPrimPath, type, uniformPrim, timeEval);
}
if(settings.EnableMdlShader)
{
SdfPath usdSamplerPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::mdlSamplerPrimPf));
InitializeMdlSampler_Impl(samplerStage, usdSamplerPrimPath, type, uniformPrim, timeEval);
}
}
template<bool PreviewSurface>
UsdShadeShader InitializeAttributeReader_Impl(UsdStageRefPtr materialStage, const SdfPath& matPrimPath, bool uniformPrim,
UsdBridgeMaterialData::DataMemberId dataMemberId, const TimeEvaluator<UsdBridgeMaterialData>* timeEval)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
if(!uniformPrim) // timevar attribute reader disabled
return UsdShadeShader();
// Create a vertexcolorreader
SdfPath attributeReaderPath = matPrimPath.AppendPath(GetAttributeReaderPathPf<PreviewSurface>(dataMemberId));
UsdShadeShader attributeReader = UsdShadeShader::Get(materialStage, attributeReaderPath);
// Allow for uniform and timevar prims to return already existing prim without triggering re-initialization
// manifest <==> timeEval, and will always take this branch
if(!attributeReader || timeEval)
{
if(!attributeReader) // Currently no need for timevar properties on attribute readers
attributeReader = UsdShadeShader::Define(materialStage, attributeReaderPath);
if(PreviewSurface)
{
if(uniformPrim) // Implies !timeEval, so initialize
{
InitializePsAttributeReaderUniform(attributeReader, GetPsAttributeReaderId(dataMemberId), GetAttributeOutputType(dataMemberId));
}
// Create attribute reader varname, and if timeEval (manifest), can also remove the input
//InitializePsAttributeReaderTimeVar(attributeReader, dataMemberId, timeEval);
}
else
{
if(uniformPrim) // Implies !timeEval, so initialize
{
InitializeMdlAttributeReaderUniform(attributeReader, GetMdlAttributeReaderSubId(dataMemberId), GetAttributeOutputType(dataMemberId));
}
//InitializeMdlAttributeReaderTimeVar(attributeReader, dataMemberId, timeEval);
}
}
return attributeReader;
}
#define INITIALIZE_ATTRIBUTE_READER_MACRO(srcAttrib, dmi) \
if(srcAttrib) InitializeAttributeReader_Impl<PreviewSurface>(materialStage, matPrimPath, false, dmi, timeEval);
template<bool PreviewSurface>
void InitializeAttributeReaderSet(UsdStageRefPtr materialStage, const SdfPath& matPrimPath, const UsdBridgeSettings& settings,
const UsdBridgeMaterialData& matData, const TimeEvaluator<UsdBridgeMaterialData>* timeEval)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
INITIALIZE_ATTRIBUTE_READER_MACRO(matData.Diffuse.SrcAttrib, DMI::DIFFUSE); \
INITIALIZE_ATTRIBUTE_READER_MACRO(matData.Opacity.SrcAttrib, DMI::OPACITY); \
INITIALIZE_ATTRIBUTE_READER_MACRO(matData.Emissive.SrcAttrib, DMI::EMISSIVECOLOR); \
INITIALIZE_ATTRIBUTE_READER_MACRO(matData.EmissiveIntensity.SrcAttrib, DMI::EMISSIVEINTENSITY); \
INITIALIZE_ATTRIBUTE_READER_MACRO(matData.Roughness.SrcAttrib, DMI::ROUGHNESS);
INITIALIZE_ATTRIBUTE_READER_MACRO(matData.Metallic.SrcAttrib, DMI::METALLIC);
INITIALIZE_ATTRIBUTE_READER_MACRO(matData.Ior.SrcAttrib, DMI::IOR);
}
void InitializeAttributeReaders_Impl(UsdStageRefPtr materialStage, const SdfPath& matPrimPath, const UsdBridgeSettings& settings,
const UsdBridgeMaterialData& matData, const TimeEvaluator<UsdBridgeMaterialData>* timeEval)
{
// So far, only used for manifest, so no uniform path required for initialization of attribute readers.
// Instead, uniform and timevar attrib readers are created on demand per-attribute in GetOrCreateAttributeReaders().
if(settings.EnablePreviewSurfaceShader)
{
InitializeAttributeReaderSet<true>(materialStage, matPrimPath, settings, matData, timeEval);
}
if(settings.EnableMdlShader)
{
InitializeAttributeReaderSet<false>(materialStage, matPrimPath, settings, matData, timeEval);
}
}
template<bool PreviewSurface>
void GetOrCreateAttributeReaders(UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, UsdBridgeMaterialData::DataMemberId dataMemberId,
UsdShadeShader& uniformReaderPrim)
{
uniformReaderPrim = InitializeAttributeReader_Impl<PreviewSurface>(sceneStage, matPrimPath, true, dataMemberId, nullptr);
//if(timeVarStage && (timeVarStage != sceneStage))
// timeVarReaderPrim = InitializeAttributeReader_Impl<PreviewSurface>(timeVarStage, matPrimPath, false, dataMemberId, nullptr);
}
template<bool PreviewSurface>
void UpdateAttributeReaderName(UsdShadeShader& uniformReaderPrim, const TfToken& nameToken)
{
// Set the correct attribute token for the reader varname
if(PreviewSurface)
{
uniformReaderPrim.GetInput(UsdBridgeTokens->varname).Set(nameToken);
}
else
{
uniformReaderPrim.GetInput(UsdBridgeTokens->name).Set(nameToken.GetString());
}
}
template<bool PreviewSurface>
void UpdateAttributeReaderOutput(UsdShadeShader& uniformReaderPrim, const UsdGeomPrimvarsAPI& boundGeomPrimvars, const TfToken& attribNameToken)
{
const TfToken& outAttribToken = PreviewSurface ? UsdBridgeTokens->result : UsdBridgeTokens->out;
UsdGeomPrimvar geomPrimvar = boundGeomPrimvars.GetPrimvar(attribNameToken);
UsdShadeOutput readerOutput = uniformReaderPrim.GetOutput(outAttribToken);
if(geomPrimvar)
{
const SdfValueTypeName& geomPrimTypeName = geomPrimvar.GetTypeName();
if(geomPrimTypeName != readerOutput.GetTypeName())
{
boundGeomPrimvars.GetPrim().RemoveProperty(PreviewSurface ? QualifiedOutputTokens->result : QualifiedOutputTokens->out);
uniformReaderPrim.CreateOutput(outAttribToken, geomPrimTypeName);
// Also change the asset subidentifier based on the outAttribToken
uniformReaderPrim.SetSourceAssetSubIdentifier(GetMdlAttributeReaderSubId(geomPrimTypeName), UsdBridgeTokens->mdl);
}
}
}
template<bool PreviewSurface>
void UpdateShaderInput_ShadeNode( const UsdShadeShader& uniformShaderIn, const UsdShadeShader& timeVarShaderIn, const TfToken& inputToken,
const UsdShadeShader& shadeNodeOut, const TfToken& outputToken,
const ShadeGraphTypeConversionNodeContext& conversionContext)
{
//Bind the shade node to the input of the uniform shader, so remove any existing values from the timeVar prim
UsdShadeInput timeVarInput = timeVarShaderIn.GetInput(inputToken);
if(timeVarInput)
timeVarInput.GetAttr().Clear();
// Connect shadeNode output to uniformShad input
UsdShadeOutput nodeOutput = shadeNodeOut.GetOutput(outputToken);
assert(nodeOutput);
UsdShadeInput shadeInput = uniformShaderIn.GetInput(inputToken);
if(!PreviewSurface)
{
conversionContext.InsertMdlShaderTypeConversionNodes(shadeInput, nodeOutput);
}
uniformShaderIn.GetInput(inputToken).ConnectToSource(nodeOutput);
}
template<bool PreviewSurface>
void UpdateShaderInputColorOpacity_Constant(UsdStageRefPtr sceneStage, const SdfPath& matPrimPath)
{
if(!PreviewSurface)
{
SdfPath opMulPrimPath = matPrimPath.AppendPath(SdfPath(constring::mdlOpacityMulPrimPf));
UsdShadeShader uniformOpMul = UsdShadeShader::Get(sceneStage, opMulPrimPath);
UsdShadeInput uniformOpMulInput = uniformOpMul.GetInput(UsdBridgeTokens->a);
assert(uniformOpMulInput);
uniformOpMulInput.Set(1.0f);
}
}
template<bool PreviewSurface>
void UpdateShaderInputColorOpacity_AttributeReader(UsdStageRefPtr materialStage,
const UsdShadeShader& outputNode, const ShadeGraphTypeConversionNodeContext& conversionContext)
{
// No PreviewSurface implementation to connect a 4 component attrib reader to a 1 component opacity input.
if(!PreviewSurface)
{
SdfPath opMulPrimPath = conversionContext.MatPrimPath.AppendPath(SdfPath(constring::mdlOpacityMulPrimPf));
UsdShadeShader uniformOpMul = UsdShadeShader::Get(conversionContext.SceneStage, opMulPrimPath);
UsdShadeShader timeVarOpMul = UsdShadeShader::Get(materialStage, opMulPrimPath);
// Input 'a' of the multiply node the target for connecting opacity to; see InitializeMdlShader
TfToken opacityInputToken = UsdBridgeTokens->a;
TfToken opacityOutputToken = UsdBridgeTokens->out;
UpdateShaderInput_ShadeNode<false>(uniformOpMul, timeVarOpMul, opacityInputToken, outputNode, opacityOutputToken, conversionContext);
}
}
template<bool PreviewSurface, typename InputValueType, typename ValueType>
void UpdateShaderInput(UsdBridgeUsdWriter* writer, UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage,
UsdShadeShader& uniformShadPrim, UsdShadeShader& timeVarShadPrim, const SdfPath& matPrimPath, const UsdGeomPrimvarsAPI& boundGeomPrimvars,
const TimeEvaluator<UsdBridgeMaterialData>& timeEval, UsdBridgeMaterialData::DataMemberId dataMemberId,
const UsdBridgeMaterialData::MaterialInput<InputValueType>& param, const TfToken& inputToken, const ValueType& inputValue)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
// Handle the case where a geometry attribute reader is connected
if (param.SrcAttrib != nullptr)
{
//bool isTimeVarying = timeEval.IsTimeVarying(dataMemberId);
// Create attribute reader(s) to connect to the material shader input
UsdShadeShader uniformReaderPrim;
GetOrCreateAttributeReaders<PreviewSurface>(sceneStage,
sceneStage, matPrimPath, dataMemberId, uniformReaderPrim);
assert(uniformReaderPrim);
const TfToken& attribNameToken = writer->AttributeNameToken(param.SrcAttrib);
UpdateAttributeReaderName<PreviewSurface>(uniformReaderPrim, writer->AttributeNameToken(param.SrcAttrib));
UpdateAttributeReaderOutput<PreviewSurface>(uniformReaderPrim, boundGeomPrimvars, attribNameToken);
// Connect the reader to the material shader input
ShadeGraphTypeConversionNodeContext conversionContext(
sceneStage, matPrimPath, GetAttributeReaderPathPf<PreviewSurface>(dataMemberId).GetString().c_str());
const TfToken& outputToken = PreviewSurface ? UsdBridgeTokens->result : UsdBridgeTokens->out;
UpdateShaderInput_ShadeNode<PreviewSurface>(uniformShadPrim, timeVarShadPrim, inputToken, uniformReaderPrim, outputToken, conversionContext);
// Diffuse attrib also has to connect to the opacitymul 'a' input. The color primvar (and therefore attrib reader out) is always a float4.
if(dataMemberId == DMI::DIFFUSE)
{
conversionContext.ConnectionIdentifier = PreviewSurface ? "" : constring::mdlDiffuseOpacityPrimPf;
conversionContext.ChannelSelector = 3; // Select the w channel from the float4 input
UpdateShaderInputColorOpacity_AttributeReader<PreviewSurface>(timeVarStage, uniformReaderPrim, conversionContext);
}
}
else if(!param.Sampler)
{
// Handle the case for normal direct values
UsdShadeInput uniformDiffInput = uniformShadPrim.GetInput(inputToken);
if(uniformDiffInput.HasConnectedSource())
uniformDiffInput.DisconnectSource();
// Just treat like regular time-varying inputs
SetShaderInput(uniformShadPrim, timeVarShadPrim, timeEval, inputToken, dataMemberId, inputValue);
// The diffuse input owns the opacitymul's 'a' input.
if(dataMemberId == DMI::DIFFUSE)
UpdateShaderInputColorOpacity_Constant<PreviewSurface>(sceneStage, matPrimPath);
}
}
// Variation for standard material shader input tokens
template<bool PreviewSurface, typename InputValueType, typename ValueType>
void UpdateShaderInput(UsdBridgeUsdWriter* writer, UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage,
UsdShadeShader& uniformShadPrim, UsdShadeShader& timeVarShadPrim, const SdfPath& matPrimPath, const UsdGeomPrimvarsAPI& boundGeomPrimvars, const TimeEvaluator<UsdBridgeMaterialData>& timeEval,
UsdBridgeMaterialData::DataMemberId dataMemberId, const UsdBridgeMaterialData::MaterialInput<InputValueType>& param, const ValueType& inputValue)
{
const TfToken& inputToken = GetMaterialShaderInputToken<PreviewSurface>(dataMemberId);
UpdateShaderInput<PreviewSurface>(writer, sceneStage, timeVarStage, uniformShadPrim, timeVarShadPrim, matPrimPath, boundGeomPrimvars, timeEval,
dataMemberId, param, inputToken, inputValue);
}
// Convenience for when param.Value is simply the intended value to be set
template<bool PreviewSurface, typename InputValueType>
void UpdateShaderInput(UsdBridgeUsdWriter* writer, UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage,
UsdShadeShader& uniformShadPrim, UsdShadeShader& timeVarShadPrim, const SdfPath& matPrimPath, const UsdGeomPrimvarsAPI& boundGeomPrimvars, const TimeEvaluator<UsdBridgeMaterialData>& timeEval,
UsdBridgeMaterialData::DataMemberId dataMemberId, const UsdBridgeMaterialData::MaterialInput<InputValueType>& param)
{
const TfToken& inputToken = GetMaterialShaderInputToken<PreviewSurface>(dataMemberId);
UpdateShaderInput<PreviewSurface>(writer, sceneStage, timeVarStage, uniformShadPrim, timeVarShadPrim, matPrimPath, boundGeomPrimvars, timeEval,
dataMemberId, param, inputToken, param.Value);
}
template<bool PreviewSurface>
void UpdateShaderInput_Sampler(const UsdShadeShader& uniformShader, const UsdShadeShader& timeVarShader,
const UsdShadeShader& refSampler, const UsdSamplerRefData& samplerRefData, const ShadeGraphTypeConversionNodeContext& conversionContext)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
DMI samplerDMI = samplerRefData.DataMemberId;
const TfToken& inputToken = GetMaterialShaderInputToken<PreviewSurface>(samplerDMI);
const TfToken& outputToken = GetSamplerOutputColorToken<PreviewSurface>(samplerRefData.ImageNumComponents);
UpdateShaderInput_ShadeNode<PreviewSurface>(uniformShader, timeVarShader, inputToken, refSampler, outputToken, conversionContext);
}
template<bool PreviewSurface>
void UpdateShaderInputColorOpacity_Sampler(const UsdShadeShader& uniformShader, const UsdShadeShader& timeVarShader,
const UsdShadeShader& refSampler, ShadeGraphTypeConversionNodeContext& conversionContext)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
TfToken opacityInputToken;
TfToken opacityOutputToken;
if(PreviewSurface)
{
opacityInputToken = GetMaterialShaderInputToken<PreviewSurface>(DMI::OPACITY);
opacityOutputToken = UsdBridgeTokens->a;
}
else
{
// Input 'a' of the multiply node the target for connecting opacity to; see InitializeMdlShader
opacityInputToken = UsdBridgeTokens->a;
opacityOutputToken = UsdBridgeTokens->out;
}
UpdateShaderInput_ShadeNode<PreviewSurface>(uniformShader, timeVarShader, opacityInputToken, refSampler, opacityOutputToken, conversionContext);
}
template<bool PreviewSurface>
void UpdateSamplerInputs(UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage, const SdfPath& samplerPrimPath, const UsdBridgeSamplerData& samplerData,
const char* imgFileName, const TfToken& attributeNameToken, const TimeEvaluator<UsdBridgeSamplerData>& timeEval)
{
typedef UsdBridgeSamplerData::DataMemberId DMI;
// Collect the various prims
SdfPath tcReaderPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::texCoordReaderPrimPf));
UsdShadeShader uniformTcReaderPrim = UsdShadeShader::Get(sceneStage, tcReaderPrimPath);
assert(uniformTcReaderPrim);
UsdShadeShader uniformSamplerPrim = UsdShadeShader::Get(sceneStage, samplerPrimPath);
assert(uniformSamplerPrim);
UsdShadeShader timeVarSamplerPrim = UsdShadeShader::Get(timeVarStage, samplerPrimPath);
assert(timeVarSamplerPrim);
SdfAssetPath texFile(imgFileName);
if(PreviewSurface)
{
// Set all the inputs
SetShaderInput(uniformSamplerPrim, timeVarSamplerPrim, timeEval, UsdBridgeTokens->file, DMI::DATA, texFile);
SetShaderInput(uniformSamplerPrim, timeVarSamplerPrim, timeEval, UsdBridgeTokens->WrapS, DMI::WRAPS, TextureWrapToken(samplerData.WrapS));
if((uint32_t)samplerData.Type >= (uint32_t)UsdBridgeSamplerData::SamplerType::SAMPLER_2D)
SetShaderInput(uniformSamplerPrim, timeVarSamplerPrim, timeEval, UsdBridgeTokens->WrapT, DMI::WRAPT, TextureWrapToken(samplerData.WrapT));
if((uint32_t)samplerData.Type >= (uint32_t)UsdBridgeSamplerData::SamplerType::SAMPLER_3D)
SetShaderInput(uniformSamplerPrim, timeVarSamplerPrim, timeEval, UsdBridgeTokens->WrapR, DMI::WRAPR, TextureWrapToken(samplerData.WrapR));
// Check whether the output type is still correct
// (Experimental: assume the output type doesn't change over time, this just gives it a chance to match the image type)
int numComponents = samplerData.ImageNumComponents;
const TfToken& outputToken = GetSamplerOutputColorToken<true>(numComponents);
if(!uniformSamplerPrim.GetOutput(outputToken))
{
// As the previous output type isn't cached, just remove everything:
uniformSamplerPrim.GetPrim().RemoveProperty(QualifiedOutputTokens->r);
uniformSamplerPrim.GetPrim().RemoveProperty(QualifiedOutputTokens->rg);
uniformSamplerPrim.GetPrim().RemoveProperty(QualifiedOutputTokens->rgb);
uniformSamplerPrim.CreateOutput(outputToken, GetSamplerOutputColorType<true>(numComponents));
}
}
else
{
// Set all the inputs
SetShaderInput(uniformSamplerPrim, timeVarSamplerPrim, timeEval, UsdBridgeTokens->tex, DMI::DATA, texFile);
SetShaderInput(uniformSamplerPrim, timeVarSamplerPrim, timeEval, UsdBridgeTokens->wrap_u, DMI::WRAPS, TextureWrapInt(samplerData.WrapS));
if((uint32_t)samplerData.Type >= (uint32_t)UsdBridgeSamplerData::SamplerType::SAMPLER_2D)
SetShaderInput(uniformSamplerPrim, timeVarSamplerPrim, timeEval, UsdBridgeTokens->wrap_v, DMI::WRAPT, TextureWrapInt(samplerData.WrapT));
if((uint32_t)samplerData.Type >= (uint32_t)UsdBridgeSamplerData::SamplerType::SAMPLER_3D)
SetShaderInput(uniformSamplerPrim, timeVarSamplerPrim, timeEval, UsdBridgeTokens->wrap_w, DMI::WRAPR, TextureWrapInt(samplerData.WrapR));
// Check whether the output type is still correct
int numComponents = samplerData.ImageNumComponents;
const TfToken& assetIdent = GetSamplerAssetSubId(numComponents);
const SdfValueTypeName& outputType = GetSamplerOutputColorType<false>(numComponents);
if(uniformSamplerPrim.GetOutput(UsdBridgeTokens->out).GetTypeName() != outputType)
{
uniformSamplerPrim.SetSourceAssetSubIdentifier(assetIdent, UsdBridgeTokens->mdl);
uniformSamplerPrim.GetPrim().RemoveProperty(QualifiedOutputTokens->out);
uniformSamplerPrim.CreateOutput(UsdBridgeTokens->out, outputType);
}
}
UpdateAttributeReaderName<PreviewSurface>(uniformTcReaderPrim, attributeNameToken);
}
void GetMaterialCoreShader(UsdStageRefPtr sceneStage, UsdStageRefPtr materialStage, const SdfPath& shaderPrimPath,
UsdShadeShader& uniformShader, UsdShadeShader& timeVarShader)
{
uniformShader = UsdShadeShader::Get(sceneStage, shaderPrimPath);
assert(uniformShader);
timeVarShader = UsdShadeShader::Get(materialStage, shaderPrimPath);
assert(timeVarShader);
}
template<bool PreviewSurface>
void GetRefSamplerPrim(UsdStageRefPtr sceneStage, const SdfPath& refSamplerPrimPath, UsdShadeShader& refSampler)
{
SdfPath refSamplerPrimPath_Child = refSamplerPrimPath.AppendPath(SdfPath(PreviewSurface ? constring::psSamplerPrimPf : constring::mdlSamplerPrimPf)); // type inherited from sampler prim (in AddRef)
refSampler = UsdShadeShader::Get(sceneStage, refSamplerPrimPath_Child);
assert(refSampler);
}
}
UsdShadeMaterial UsdBridgeUsdWriter::InitializeUsdMaterial(UsdStageRefPtr materialStage, const SdfPath& matPrimPath, bool uniformPrim) const
{
return InitializeUsdMaterial_Impl(materialStage, matPrimPath, uniformPrim, Settings);
}
void UsdBridgeUsdWriter::InitializeUsdSampler(UsdStageRefPtr samplerStage,const SdfPath& samplerPrimPath, UsdBridgeSamplerData::SamplerType type, bool uniformPrim) const
{
InitializeSampler_Impl(samplerStage, samplerPrimPath, type, uniformPrim, Settings);
}
#ifdef USE_INDEX_MATERIALS
namespace
{
UsdShadeOutput InitializeIndexShaderUniform(UsdStageRefPtr volumeStage, UsdShadeShader& indexShader, UsdPrim& colorMapPrim)
{
UsdShadeConnectableAPI colorMapConn(colorMapPrim);
UsdShadeOutput colorMapShadOut = colorMapConn.CreateOutput(UsdBridgeTokens->colormap, SdfValueTypeNames->Token);
colorMapPrim.CreateAttribute(UsdBridgeTokens->domainBoundaryMode , SdfValueTypeNames->Token).Set(UsdBridgeTokens->clampToEdge);
colorMapPrim.CreateAttribute(UsdBridgeTokens->colormapSource , SdfValueTypeNames->Token).Set(UsdBridgeTokens->colormapValues);
indexShader.CreateInput(UsdBridgeTokens->colormap, SdfValueTypeNames->Token).ConnectToSource(colorMapShadOut);
return indexShader.CreateOutput(UsdBridgeTokens->volume, SdfValueTypeNames->Token);
}
void InitializeIndexShaderTimeVar(UsdPrim& colorMapPrim, const TimeEvaluator<UsdBridgeVolumeData>* timeEval = nullptr)
{
typedef UsdBridgeVolumeData::DataMemberId DMI;
// Value range
CREATE_REMOVE_TIMEVARYING_ATTRIB(colorMapPrim, DMI::TFVALUERANGE, UsdBridgeTokens->domain, SdfValueTypeNames->Float2);
// Colors and opacities are grouped into the same attrib
CREATE_REMOVE_TIMEVARYING_ATTRIB(colorMapPrim, (DMI::TFCOLORS | DMI::TFOPACITIES), UsdBridgeTokens->colormapValues, SdfValueTypeNames->Float4Array);
}
}
UsdShadeMaterial UsdBridgeUsdWriter::InitializeIndexVolumeMaterial_Impl(UsdStageRefPtr volumeStage,
const SdfPath& volumePath, bool uniformPrim, const TimeEvaluator<UsdBridgeVolumeData>* timeEval) const
{
SdfPath indexMatPath = volumePath.AppendPath(SdfPath(constring::indexMaterialPf));
SdfPath indexShadPath = indexMatPath.AppendPath(SdfPath(constring::indexShaderPf));
SdfPath colorMapPath = indexMatPath.AppendPath(SdfPath(constring::indexColorMapPf));
UsdShadeMaterial indexMaterial = GetOrDefinePrim<UsdShadeMaterial>(volumeStage, indexMatPath);
assert(indexMaterial);
UsdPrim colorMapPrim = volumeStage->GetPrimAtPath(colorMapPath);
if(!colorMapPrim)
colorMapPrim = volumeStage->DefinePrim(colorMapPath, UsdBridgeTokens->Colormap);
assert(colorMapPrim);
if(uniformPrim)
{
UsdShadeShader indexShader = GetOrDefinePrim<UsdShadeShader>(volumeStage, indexShadPath);
assert(indexShader);
UsdShadeOutput indexShaderOutput = InitializeIndexShaderUniform(volumeStage, indexShader, colorMapPrim);
indexMaterial.CreateVolumeOutput(UsdBridgeTokens->nvindex).ConnectToSource(indexShaderOutput);
}
InitializeIndexShaderTimeVar(colorMapPrim, timeEval);
return indexMaterial;
}
#endif
#ifdef VALUE_CLIP_RETIMING
void UsdBridgeUsdWriter::UpdateUsdMaterialManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeMaterialData& matData)
{
TimeEvaluator<UsdBridgeMaterialData> timeEval(matData);
InitializeUsdMaterial_Impl(cacheEntry->ManifestStage.second, cacheEntry->PrimPath, false,
Settings, &timeEval);
InitializeAttributeReaders_Impl(cacheEntry->ManifestStage.second, cacheEntry->PrimPath,
Settings, matData, &timeEval);
if(this->EnableSaving)
cacheEntry->ManifestStage.second->Save();
}
void UsdBridgeUsdWriter::UpdateUsdSamplerManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeSamplerData& samplerData)
{
TimeEvaluator<UsdBridgeSamplerData> timeEval(samplerData);
InitializeSampler_Impl(cacheEntry->ManifestStage.second, cacheEntry->PrimPath, samplerData.Type,
false, Settings, &timeEval);
if(this->EnableSaving)
cacheEntry->ManifestStage.second->Save();
}
#endif
void UsdBridgeUsdWriter::ConnectSamplersToMaterial(UsdStageRefPtr materialStage, const SdfPath& matPrimPath, const SdfPrimPathList& refSamplerPrimPaths,
const UsdBridgePrimCacheList& samplerCacheEntries, const UsdSamplerRefData* samplerRefDatas, size_t numSamplers, double worldTimeStep)
{
typedef UsdBridgeMaterialData::DataMemberId DMI;
// Essentially, this is an extension of UpdateShaderInput() for the case of param.Sampler
if(Settings.EnablePreviewSurfaceShader)
{
SdfPath shaderPrimPath = matPrimPath.AppendPath(SdfPath(constring::psShaderPrimPf));
UsdShadeShader uniformShad, timeVarShad;
GetMaterialCoreShader(this->SceneStage, materialStage, shaderPrimPath,
uniformShad, timeVarShad);
for(int i = 0; i < numSamplers; ++i)
{
const char* samplerPrimName = samplerCacheEntries[i]->Name.GetString().c_str();
UsdShadeShader refSampler;
GetRefSamplerPrim<true>(this->SceneStage, refSamplerPrimPaths[i], refSampler);
ShadeGraphTypeConversionNodeContext conversionContext(
this->SceneStage, matPrimPath, samplerPrimName);
UpdateShaderInput_Sampler<true>(uniformShad, timeVarShad, refSampler, samplerRefDatas[i], conversionContext);
bool affectsOpacity = samplerRefDatas[i].DataMemberId == DMI::DIFFUSE && samplerRefDatas[i].ImageNumComponents == 4;
if(affectsOpacity)
UpdateShaderInputColorOpacity_Sampler<true>(uniformShad, timeVarShad, refSampler, conversionContext);
}
}
if(Settings.EnableMdlShader)
{
// Get shader prims
SdfPath shaderPrimPath = matPrimPath.AppendPath(SdfPath(constring::mdlShaderPrimPf));
SdfPath opMulPrimPath = matPrimPath.AppendPath(SdfPath(constring::mdlOpacityMulPrimPf));
UsdShadeShader uniformShad, timeVarShad;
GetMaterialCoreShader(this->SceneStage, materialStage, shaderPrimPath,
uniformShad, timeVarShad);
UsdShadeShader uniformOpMul = UsdShadeShader::Get(this->SceneStage, opMulPrimPath);
UsdShadeShader timeVarOpMul = UsdShadeShader::Get(materialStage, opMulPrimPath);
for(int i = 0; i < numSamplers; ++i)
{
const char* samplerPrimName = samplerCacheEntries[i]->Name.GetString().c_str();
UsdShadeShader refSampler;
GetRefSamplerPrim<false>(this->SceneStage, refSamplerPrimPaths[i], refSampler);
ShadeGraphTypeConversionNodeContext conversionContext(
this->SceneStage, matPrimPath, samplerPrimName);
if(samplerRefDatas[i].DataMemberId != DMI::OPACITY)
{
UpdateShaderInput_Sampler<false>(uniformShad, timeVarShad, refSampler, samplerRefDatas[i], conversionContext);
bool affectsOpacity = samplerRefDatas[i].DataMemberId == DMI::DIFFUSE;
if(affectsOpacity)
{
if(samplerRefDatas[i].ImageNumComponents == 4)
{
conversionContext.ConnectionIdentifier = constring::mdlDiffuseOpacityPrimPf;
conversionContext.ChannelSelector = 3; // Select the w channel from the float4 input
// Connect diffuse sampler to the opacity mul node instead of the main shader; see InitializeMdlShader
UpdateShaderInputColorOpacity_Sampler<false>(uniformOpMul, timeVarOpMul, refSampler, conversionContext);
}
else
UpdateShaderInputColorOpacity_Constant<false>(this->SceneStage, matPrimPath); // Since a sampler was bound, the constant is not set during UpdateShaderInput()
}
}
else
{
// Connect opacity sampler to the 'b' input of opacity mul node, similar to UpdateMdlShader (for attribute readers)
UpdateShaderInput_ShadeNode<false>(uniformOpMul, timeVarOpMul, UsdBridgeTokens->b, refSampler, UsdBridgeTokens->out, conversionContext);
}
}
}
}
void UsdBridgeUsdWriter::UpdateUsdMaterial(UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, const UsdBridgeMaterialData& matData, const UsdGeomPrimvarsAPI& boundGeomPrimvars, double timeStep)
{
// Update usd shader
if(Settings.EnablePreviewSurfaceShader)
{
this->UpdatePsShader(timeVarStage, matPrimPath, matData, boundGeomPrimvars, timeStep);
}
if(Settings.EnableMdlShader)
{
// Update mdl shader
this->UpdateMdlShader(timeVarStage, matPrimPath, matData, boundGeomPrimvars, timeStep);
}
}
#define UPDATE_USD_SHADER_INPUT_MACRO(...) \
UpdateShaderInput<true>(this, SceneStage, timeVarStage, uniformShadPrim, timeVarShadPrim, matPrimPath, boundGeomPrimvars, timeEval, __VA_ARGS__)
void UsdBridgeUsdWriter::UpdatePsShader(UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, const UsdBridgeMaterialData& matData, const UsdGeomPrimvarsAPI& boundGeomPrimvars, double timeStep)
{
TimeEvaluator<UsdBridgeMaterialData> timeEval(matData, timeStep);
typedef UsdBridgeMaterialData::DataMemberId DMI;
SdfPath shadPrimPath = matPrimPath.AppendPath(SdfPath(constring::psShaderPrimPf));
UsdShadeShader uniformShadPrim = UsdShadeShader::Get(SceneStage, shadPrimPath);
assert(uniformShadPrim);
UsdShadeShader timeVarShadPrim = UsdShadeShader::Get(timeVarStage, shadPrimPath);
assert(timeVarShadPrim);
GfVec3f difColor(GetValuePtr(matData.Diffuse));
GfVec3f emColor(GetValuePtr(matData.Emissive));
emColor *= matData.EmissiveIntensity.Value; // This multiplication won't translate to vcr/sampler usage
//uniformShadPrim.GetInput(UsdBridgeTokens->useSpecularWorkflow).Set(
// (matData.Metallic.Value > 0.0 || matData.Metallic.SrcAttrib || matData.Metallic.Sampler) ? 0 : 1);
UPDATE_USD_SHADER_INPUT_MACRO(DMI::DIFFUSE, matData.Diffuse, difColor);
UPDATE_USD_SHADER_INPUT_MACRO(DMI::EMISSIVECOLOR, matData.Emissive, emColor);
UPDATE_USD_SHADER_INPUT_MACRO(DMI::ROUGHNESS, matData.Roughness);
UPDATE_USD_SHADER_INPUT_MACRO(DMI::OPACITY, matData.Opacity);
UPDATE_USD_SHADER_INPUT_MACRO(DMI::METALLIC, matData.Metallic);
UPDATE_USD_SHADER_INPUT_MACRO(DMI::IOR, matData.Ior);
// Just a value, not connected to attribreaders or samplers
float opacityCutoffValue = (matData.AlphaMode == UsdBridgeMaterialData::AlphaModes::MASK) ? matData.AlphaCutoff : 0.0f; // don't enable cutoff when not explicitly specified
SetShaderInput(uniformShadPrim, timeVarShadPrim, timeEval, UsdBridgeTokens->opacityThreshold, DMI::OPACITY, opacityCutoffValue);
}
#define UPDATE_MDL_SHADER_INPUT_MACRO(...) \
UpdateShaderInput<false>(this, SceneStage, timeVarStage, uniformShadPrim, timeVarShadPrim, matPrimPath, boundGeomPrimvars, timeEval, __VA_ARGS__)
void UsdBridgeUsdWriter::UpdateMdlShader(UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, const UsdBridgeMaterialData& matData, const UsdGeomPrimvarsAPI& boundGeomPrimvars, double timeStep)
{
TimeEvaluator<UsdBridgeMaterialData> timeEval(matData, timeStep);
typedef UsdBridgeMaterialData::DataMemberId DMI;
SdfPath shadPrimPath = matPrimPath.AppendPath(SdfPath(constring::mdlShaderPrimPf));
UsdShadeShader uniformShadPrim = UsdShadeShader::Get(SceneStage, shadPrimPath);
assert(uniformShadPrim);
UsdShadeShader timeVarShadPrim = UsdShadeShader::Get(timeVarStage, shadPrimPath);
assert(timeVarShadPrim);
SdfPath opMulPrimPath = matPrimPath.AppendPath(SdfPath(constring::mdlOpacityMulPrimPf));
UsdShadeShader uniformOpMulPrim = UsdShadeShader::Get(SceneStage, opMulPrimPath);
assert(uniformOpMulPrim);
UsdShadeShader timeVarOpMulPrim = UsdShadeShader::Get(timeVarStage, opMulPrimPath);
assert(timeVarOpMulPrim);
GfVec3f difColor(GetValuePtr(matData.Diffuse));
GfVec3f emColor(GetValuePtr(matData.Emissive));
bool enableEmission = (matData.EmissiveIntensity.Value >= 0.0 || matData.EmissiveIntensity.SrcAttrib || matData.EmissiveIntensity.Sampler);
// Only set values on either timevar or uniform prim
UPDATE_MDL_SHADER_INPUT_MACRO(DMI::DIFFUSE, matData.Diffuse, difColor);
UPDATE_MDL_SHADER_INPUT_MACRO(DMI::EMISSIVECOLOR, matData.Emissive, emColor);
UPDATE_MDL_SHADER_INPUT_MACRO(DMI::EMISSIVEINTENSITY, matData.EmissiveIntensity);
UPDATE_MDL_SHADER_INPUT_MACRO(DMI::ROUGHNESS, matData.Roughness);
UPDATE_MDL_SHADER_INPUT_MACRO(DMI::METALLIC, matData.Metallic);
//UPDATE_MDL_SHADER_INPUT_MACRO(DMI::IOR, matData.Ior);
UpdateShaderInput<false>(this, SceneStage, timeVarStage, uniformOpMulPrim, timeVarOpMulPrim, matPrimPath, boundGeomPrimvars,
timeEval, DMI::OPACITY, matData.Opacity, UsdBridgeTokens->b, matData.Opacity.Value); // Connect to the mul shader 'b' input, instead of the opacity input directly
// Just a value, not connected to attribreaders or samplers
float opacityCutoffValue = (matData.AlphaMode == UsdBridgeMaterialData::AlphaModes::MASK) ? matData.AlphaCutoff : 0.0f; // don't enable cutoff when not explicitly specified
bool enableOpacity = matData.AlphaMode != UsdBridgeMaterialData::AlphaModes::NONE;
SetShaderInput(uniformShadPrim, timeVarShadPrim, timeEval, UsdBridgeTokens->opacity_threshold, DMI::OPACITY, opacityCutoffValue);
SetShaderInput(uniformShadPrim, timeVarShadPrim, timeEval, UsdBridgeTokens->enable_opacity, DMI::OPACITY, enableOpacity);
SetShaderInput(uniformShadPrim, timeVarShadPrim, timeEval, UsdBridgeTokens->enable_emission, DMI::EMISSIVEINTENSITY, enableEmission);
#ifdef CUSTOM_PBR_MDL
if (!enableOpacity)
uniformShadPrim.SetSourceAsset(this->MdlOpaqueRelFilePath, UsdBridgeTokens->mdl);
else
uniformShadPrim.SetSourceAsset(this->MdlTranslucentRelFilePath, UsdBridgeTokens->mdl);
#endif
}
void UsdBridgeUsdWriter::UpdateUsdSampler(UsdStageRefPtr timeVarStage, UsdBridgePrimCache* cacheEntry, const UsdBridgeSamplerData& samplerData, double timeStep)
{
TimeEvaluator<UsdBridgeSamplerData> timeEval(samplerData, timeStep);
typedef UsdBridgeSamplerData::DataMemberId DMI;
const SdfPath& samplerPrimPath = cacheEntry->PrimPath;
// Generate an image url
const std::string& defaultName = cacheEntry->Name.GetString();
const std::string& generatedFileName = GetResourceFileName(constring::imgFolder, samplerData.ImageName, defaultName, timeStep, constring::imageExtension);
const char* imgFileName = samplerData.ImageUrl;
bool writeFile = false; // No resource key is stored if no file is written
if(!imgFileName)
{
imgFileName = generatedFileName.c_str();
writeFile = true;
}
const TfToken& attribNameToken = AttributeNameToken(samplerData.InAttribute);
if(Settings.EnablePreviewSurfaceShader)
{
SdfPath usdSamplerPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::psSamplerPrimPf));
UpdateSamplerInputs<true>(SceneStage, timeVarStage, usdSamplerPrimPath, samplerData, imgFileName, attribNameToken, timeEval);
}
if(Settings.EnableMdlShader)
{
SdfPath usdSamplerPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::mdlSamplerPrimPf));
UpdateSamplerInputs<false>(SceneStage, timeVarStage, usdSamplerPrimPath, samplerData, imgFileName, attribNameToken, timeEval);
}
// Update resources
if(writeFile)
{
// Create a resource reference representing the file write
const char* resourceName = samplerData.ImageName ? samplerData.ImageName : defaultName.c_str();
UsdBridgeResourceKey key(resourceName, timeStep);
bool newEntry = cacheEntry->AddResourceKey(key);
bool isSharedResource = samplerData.ImageName;
if(newEntry && isSharedResource)
AddSharedResourceRef(key);
// Upload as image to texFile (in case this hasn't yet been performed)
assert(samplerData.Data);
if(!isSharedResource || !SetSharedResourceModified(key))
{
TempImageData.resize(0);
const void* convertedSamplerData = nullptr;
int64_t convertedSamplerStride = samplerData.ImageStride[1];
int numComponents = samplerData.ImageNumComponents;
UsdBridgeType flattenedType = ubutils::UsdBridgeTypeFlatten(samplerData.DataType);
if( !(flattenedType == UsdBridgeType::UCHAR || flattenedType == UsdBridgeType::UCHAR_SRGB_R))
{
// Convert to 8-bit image data
ConvertSamplerDataToImage(samplerData, TempImageData);
if(TempImageData.size())
{
convertedSamplerData = TempImageData.data();
convertedSamplerStride = samplerData.ImageDims[0]*numComponents;
}
}
else
{
convertedSamplerData = samplerData.Data;
}
if(numComponents <= 4 && convertedSamplerData)
{
StbWriteOutput writeOutput;
stbi_write_png_to_func(StbWriteToBuffer, &writeOutput,
static_cast<int>(samplerData.ImageDims[0]), static_cast<int>(samplerData.ImageDims[1]),
numComponents, convertedSamplerData, convertedSamplerStride);
// Filename, relative from connection working dir
std::string wdRelFilename(SessionDirectory + imgFileName);
Connect->WriteFile(writeOutput.imageData, writeOutput.imageSize, wdRelFilename.c_str(), true);
}
else
{
UsdBridgeLogMacro(this->LogObject, UsdBridgeLogLevel::WARNING, "Image file not written out, format not supported (should be 1-4 component unsigned char/short/int or float/double): " << samplerData.ImageName);
}
}
}
}
namespace
{
template<bool PreviewSurface>
void UpdateAttributeReader_Impl(UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath,
UsdBridgeMaterialData::DataMemberId dataMemberId, const TfToken& newNameToken, const UsdGeomPrimvarsAPI& boundGeomPrimvars,
const TimeEvaluator<UsdBridgeMaterialData>& timeEval, const UsdBridgeLogObject& logObj)
{
typedef UsdBridgeMaterialData::DataMemberId DMI;
if(PreviewSurface && dataMemberId == DMI::EMISSIVEINTENSITY)
return; // Emissive intensity is not represented as a shader input in the USD preview surface model
// Collect the various prims
SdfPath attributeReaderPath = matPrimPath.AppendPath(GetAttributeReaderPathPf<PreviewSurface>(dataMemberId));
UsdShadeShader uniformAttribReader = UsdShadeShader::Get(sceneStage, attributeReaderPath);
if(!uniformAttribReader)
{
UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "In UpdateAttributeReader_Impl(): requesting an attribute reader that hasn't been created during fixup of name token.");
return;
}
UpdateAttributeReaderName<PreviewSurface>(uniformAttribReader, newNameToken);
UpdateAttributeReaderOutput<PreviewSurface>(uniformAttribReader, boundGeomPrimvars, newNameToken);
}
template<bool PreviewSurface>
void UpdateSamplerTcReader(UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage, const SdfPath& samplerPrimPath, const TfToken& newNameToken, const TimeEvaluator<UsdBridgeSamplerData>& timeEval)
{
typedef UsdBridgeSamplerData::DataMemberId DMI;
// Collect the various prims
SdfPath tcReaderPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::texCoordReaderPrimPf));
UsdShadeShader uniformTcReaderPrim = UsdShadeShader::Get(sceneStage, tcReaderPrimPath);
assert(uniformTcReaderPrim);
// Set the new Inattribute
UpdateAttributeReaderName<PreviewSurface>(uniformTcReaderPrim, newNameToken);
}
}
void UsdBridgeUsdWriter::UpdateAttributeReader(UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, MaterialDMI dataMemberId, const char* newName, const UsdGeomPrimvarsAPI& boundGeomPrimvars, double timeStep, MaterialDMI timeVarying)
{
// Time eval with dummy data
UsdBridgeMaterialData materialData;
materialData.TimeVarying = timeVarying;
TimeEvaluator<UsdBridgeMaterialData> timeEval(materialData, timeStep);
const TfToken& newNameToken = AttributeNameToken(newName);
if(Settings.EnablePreviewSurfaceShader)
{
UpdateAttributeReader_Impl<true>(SceneStage, timeVarStage, matPrimPath, dataMemberId, newNameToken, boundGeomPrimvars, timeEval, this->LogObject);
}
if(Settings.EnableMdlShader)
{
UpdateAttributeReader_Impl<false>(SceneStage, timeVarStage, matPrimPath, dataMemberId, newNameToken, boundGeomPrimvars, timeEval, this->LogObject);
}
}
void UsdBridgeUsdWriter::UpdateInAttribute(UsdStageRefPtr timeVarStage, const SdfPath& samplerPrimPath, const char* newName, double timeStep, SamplerDMI timeVarying)
{
// Time eval with dummy data
UsdBridgeSamplerData samplerData;
samplerData.TimeVarying = timeVarying;
TimeEvaluator<UsdBridgeSamplerData> timeEval(samplerData, timeStep);
const TfToken& newNameToken = AttributeNameToken(newName);
if(Settings.EnablePreviewSurfaceShader)
{
SdfPath usdSamplerPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::psSamplerPrimPf));
UpdateSamplerTcReader<true>(SceneStage, timeVarStage, usdSamplerPrimPath, newNameToken, timeEval);
}
if(Settings.EnableMdlShader)
{
SdfPath usdSamplerPrimPath = samplerPrimPath.AppendPath(SdfPath(constring::mdlSamplerPrimPf));
UpdateSamplerTcReader<false>(SceneStage, timeVarStage, usdSamplerPrimPath, newNameToken, timeEval);
}
}
#ifdef USE_INDEX_MATERIALS
void UsdBridgeUsdWriter::UpdateIndexVolumeMaterial(UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage, const SdfPath& volumePath, const UsdBridgeVolumeData& volumeData, double timeStep)
{
TimeEvaluator<UsdBridgeVolumeData> timeEval(volumeData, timeStep);
typedef UsdBridgeVolumeData::DataMemberId DMI;
SdfPath indexMatPath = volumePath.AppendPath(SdfPath(constring::indexMaterialPf));
SdfPath colorMapPath = indexMatPath.AppendPath(SdfPath(constring::indexColorMapPf));
// Renormalize the value range based on the volume data type (see CopyToGrid in the volumewriter)
GfVec2f valueRange(GfVec2d(volumeData.TfData.TfValueRange));
// Set the transfer function value array from opacities and colors
assert(volumeData.TfData.TfOpacitiesType == UsdBridgeType::FLOAT);
const float* tfOpacities = static_cast<const float*>(volumeData.TfData.TfOpacities);
// Set domain and colormap values
UsdPrim uniformColorMap = sceneStage->GetPrimAtPath(colorMapPath);
assert(uniformColorMap);
UsdPrim timeVarColorMap = timeVarStage->GetPrimAtPath(colorMapPath);
assert(timeVarColorMap);
UsdAttribute uniformDomainAttr = uniformColorMap.GetAttribute(UsdBridgeTokens->domain);
UsdAttribute timeVarDomainAttr = timeVarColorMap.GetAttribute(UsdBridgeTokens->domain);
UsdAttribute uniformTfValueAttr = uniformColorMap.GetAttribute(UsdBridgeTokens->colormapValues);
UsdAttribute timeVarTfValueAttr = timeVarColorMap.GetAttribute(UsdBridgeTokens->colormapValues);
// Timevarying colormaps/domains are currently not supported by index, so keep this switched off
bool rangeTimeVarying = false;//timeEval.IsTimeVarying(DMI::TFVALUERANGE);
bool valuesTimeVarying = false;//timeEval.IsTimeVarying(DMI::TFCOLORS) || timeEval.IsTimeVarying(DMI::TFOPACITIES);
// Clear timevarying attributes if necessary
ClearUsdAttributes(uniformDomainAttr, timeVarDomainAttr, rangeTimeVarying);
ClearUsdAttributes(uniformTfValueAttr, timeVarTfValueAttr, valuesTimeVarying);
// Set the attributes
UsdAttribute& outAttrib = valuesTimeVarying ? timeVarTfValueAttr : uniformTfValueAttr;
UsdTimeCode outTimeCode = valuesTimeVarying ? timeEval.TimeCode : timeEval.Default();
VtVec4fArray* outArray = AssignColorArrayToPrimvar(LogObject, volumeData.TfData.TfColors, volumeData.TfData.TfNumColors, volumeData.TfData.TfColorsType,
outTimeCode,
outAttrib,
false); // Get the pointer, set the data manually here
for(size_t i = 0; i < outArray->size() && i < volumeData.TfData.TfNumOpacities; ++i)
(*outArray)[i][3] = tfOpacities[i]; // Set the alpha channel
if(outArray)
outAttrib.Set(*outArray, outTimeCode);
SET_TIMEVARYING_ATTRIB(rangeTimeVarying, timeVarDomainAttr, uniformDomainAttr, valueRange);
}
#endif
void ResourceCollectSampler(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter)
{
RemoveResourceFiles(cache, usdWriter, constring::imgFolder, constring::imageExtension);
}
| 71,332 | C++ | 46.587058 | 237 | 0.769514 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridge.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridge_h
#define UsdBridge_h
#include "UsdBridgeData.h"
struct UsdBridgeInternals;
typedef void* SceneStagePtr; // Placeholder for UsdStage*
class UsdBridge
{
public:
using MaterialDMI = UsdBridgeMaterialData::DataMemberId;
using SamplerDMI = UsdBridgeSamplerData::DataMemberId;
using MaterialInputAttribName = std::pair<MaterialDMI, const char*>;
UsdBridge(const UsdBridgeSettings& settings);
~UsdBridge();
void SetExternalSceneStage(SceneStagePtr sceneStage);
void SetEnableSaving(bool enableSaving);
bool OpenSession(UsdBridgeLogCallback logCallback, void* logUserData);
bool GetSessionValid() const { return SessionValid; }
void CloseSession();
bool CreateWorld(const char* name, UsdWorldHandle& handle);
bool CreateInstance(const char* name, UsdInstanceHandle& handle);
bool CreateGroup(const char* name, UsdGroupHandle& handle);
bool CreateSurface(const char* name, UsdSurfaceHandle& handle);
bool CreateVolume(const char* name, UsdVolumeHandle& handle);
bool CreateGeometry(const char* name, UsdGeometryHandle& handle, const UsdBridgeMeshData& meshData);
bool CreateGeometry(const char* name, UsdGeometryHandle& handle, const UsdBridgeInstancerData& instancerData);
bool CreateGeometry(const char* name, UsdGeometryHandle& handle, const UsdBridgeCurveData& curveData);
bool CreateSpatialField(const char* name, UsdSpatialFieldHandle& handle);
bool CreateMaterial(const char* name, UsdMaterialHandle& handle);
bool CreateSampler(const char* name, UsdSamplerHandle& handle, UsdBridgeSamplerData::SamplerType type);
bool CreateCamera(const char* name, UsdCameraHandle& handle);
void DeleteWorld(UsdWorldHandle handle);
void DeleteInstance(UsdInstanceHandle handle);
void DeleteGroup(UsdGroupHandle handle);
void DeleteSurface(UsdSurfaceHandle handle);
void DeleteVolume(UsdVolumeHandle handle);
void DeleteGeometry(UsdGeometryHandle handle);
void DeleteSpatialField(UsdSpatialFieldHandle handle);
void DeleteMaterial(UsdMaterialHandle handle);
void DeleteSampler(UsdSamplerHandle handle);
void DeleteCamera(UsdCameraHandle handle);
void SetInstanceRefs(UsdWorldHandle world, const UsdInstanceHandle* instances, uint64_t numInstances, bool timeVarying, double timeStep);
void SetGroupRef(UsdInstanceHandle instance, UsdGroupHandle group, bool timeVarying, double timeStep);
void SetSurfaceRefs(UsdWorldHandle world, const UsdSurfaceHandle* surfaces, uint64_t numSurfaces, bool timeVarying, double timeStep);
void SetSurfaceRefs(UsdGroupHandle group, const UsdSurfaceHandle* surfaces, uint64_t numSurfaces, bool timeVarying, double timeStep);
void SetVolumeRefs(UsdWorldHandle world, const UsdVolumeHandle* volumes, uint64_t numVolumes, bool timeVarying, double timeStep);
void SetVolumeRefs(UsdGroupHandle group, const UsdVolumeHandle* volumes, uint64_t numVolumes, bool timeVarying, double timeStep);
void SetGeometryRef(UsdSurfaceHandle surface, UsdGeometryHandle geometry, double timeStep, double geomTimeStep);
void SetGeometryMaterialRef(UsdSurfaceHandle surface, UsdGeometryHandle geometry, UsdMaterialHandle material, double timeStep, double geomTimeStep, double matTimeStep);
void SetSpatialFieldRef(UsdVolumeHandle volume, UsdSpatialFieldHandle field, double timeStep, double fieldTimeStep);
void SetSamplerRefs(UsdMaterialHandle material, const UsdSamplerHandle* samplers, size_t numSamplers, double timeStep, const UsdSamplerRefData* samplerRefData);
void SetPrototypeRefs(UsdGeometryHandle geometry, const UsdGeometryHandle* protoGeometries, size_t numProtoGeometries, double timeStep, double* protoTimeSteps);
void DeleteInstanceRefs(UsdWorldHandle world, bool timeVarying, double timeStep);
void DeleteGroupRef(UsdInstanceHandle instance, bool timeVarying, double timeStep);
void DeleteSurfaceRefs(UsdWorldHandle world, bool timeVarying, double timeStep);
void DeleteSurfaceRefs(UsdGroupHandle group, bool timeVarying, double timeStep);
void DeleteVolumeRefs(UsdWorldHandle world, bool timeVarying, double timeStep);
void DeleteVolumeRefs(UsdGroupHandle group, bool timeVarying, double timeStep);
void DeleteGeometryRef(UsdSurfaceHandle surface, double timeStep);
void DeleteSpatialFieldRef(UsdVolumeHandle volume, double timeStep);
void DeleteMaterialRef(UsdSurfaceHandle surface, double timeStep);
void DeleteSamplerRefs(UsdMaterialHandle material, double timeStep);
void DeletePrototypeRefs(UsdGeometryHandle geometry, double timeStep);
void UpdateBeginEndTime(double timeStep);
void SetInstanceTransform(UsdInstanceHandle instance, const float* transform, bool timeVarying, double timeStep);
void SetGeometryData(UsdGeometryHandle geometry, const UsdBridgeMeshData& meshData, double timeStep);
void SetGeometryData(UsdGeometryHandle geometry, const UsdBridgeInstancerData& instancerData, double timeStep);
void SetGeometryData(UsdGeometryHandle geometry, const UsdBridgeCurveData& curveData, double timeStep);
void SetSpatialFieldData(UsdSpatialFieldHandle field, const UsdBridgeVolumeData& volumeData, double timeStep);
void SetMaterialData(UsdMaterialHandle material, const UsdBridgeMaterialData& matData, double timeStep);
void SetSamplerData(UsdSamplerHandle sampler, const UsdBridgeSamplerData& samplerData, double timeStep);
void SetCameraData(UsdCameraHandle camera, const UsdBridgeCameraData& cameraData, double timeStep);
void SetPrototypeData(UsdGeometryHandle geometry, const UsdBridgeInstancerRefData& instancerRefData); // UsdBridgeInstancerRefData::Shapes used to index into refs from last SetPrototypeRefs (if SHAPE_MESH)
void ChangeMaterialInputAttributes(UsdMaterialHandle material, const MaterialInputAttribName* inputAttribs, size_t numInputAttribs, double timeStep, MaterialDMI timeVarying);
void ChangeInAttribute(UsdSamplerHandle sampler, const char* newName, double timeStep, SamplerDMI timeVarying);
void SaveScene();
void ResetResourceUpdateState(); // Eg. clears all dirty flags on shared resources
void GarbageCollect(); // Deletes all handles without parents (from Set<X>Refs)
const char* GetPrimPath(UsdBridgeHandle* handle);
//
// Static parameter interface
//
static void SetConnectionLogVerbosity(int logVerbosity); // 0 <= logVerbosity <= 4, 0 is quietest
protected:
template<typename GeomDataType>
bool CreateGeometryTemplate(const char* name, UsdGeometryHandle& handle, const GeomDataType& geomData);
template<typename GeomDataType>
void SetGeometryDataTemplate(UsdGeometryHandle geometry, const GeomDataType& geomData, double timeStep);
template<typename ParentHandleType, typename ChildHandleType>
void SetNoClipRefs(ParentHandleType parentHandle, const ChildHandleType* childHandles, uint64_t numChildren,
const char* refPathExt, bool timeVarying, double timeStep, bool instanceable = false);
template<typename ParentHandleType>
void DeleteAllRefs(ParentHandleType parentHandle, const char* refPathExt, bool timeVarying, double timeStep);
void CreateRootPrimAndAttach(UsdBridgePrimCache* cacheEntry, const char* primPathCp, const char* layerId = nullptr);
void RemoveRootPrimAndDetach(UsdBridgePrimCache* cacheEntry, const char* primPathCp);
UsdBridgeInternals* Internals;
bool EnableSaving;
bool SessionValid;
};
#endif
| 7,571 | C | 57.246153 | 209 | 0.799498 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeDiagnosticMgrDelegate.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeDiagnosticMgrDelegate_h
#define UsdBridgeDiagnosticMgrDelegate_h
#include "UsdBridgeData.h"
#include "usd.h"
PXR_NAMESPACE_USING_DIRECTIVE
class UsdBridgeDiagnosticMgrDelegate : public TfDiagnosticMgr::Delegate
{
public:
UsdBridgeDiagnosticMgrDelegate(void* logUserData,
UsdBridgeLogCallback logCallback);
void IssueError(TfError const& err) override;
void IssueFatalError(TfCallContext const& context,
std::string const& msg) override;
void IssueStatus(TfStatus const& status) override;
void IssueWarning(TfWarning const& warning) override;
static void SetOutputEnabled(bool enable){ OutputEnabled = enable; }
protected:
void LogTfMessage(UsdBridgeLogLevel level, TfDiagnosticBase const& diagBase);
void LogMessage(UsdBridgeLogLevel level, const std::string& message);
void* LogUserData;
UsdBridgeLogCallback LogCallback;
static bool OutputEnabled;
};
#endif | 1,026 | C | 24.674999 | 81 | 0.769981 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/usd.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#pragma warning(push)
#pragma warning(disable:4244) // = Conversion from double to float / int to float
#pragma warning(disable:4305) // argument truncation from double to float
#pragma warning(disable:4800) // int to bool
#pragma warning(disable:4996) // call to std::copy with parameters that may be unsafe
#define NOMINMAX // Make sure nobody #defines min or max
// Python must be included first because it monkeys with macros that cause
// TBB to fail to compile in debug mode if TBB is included before Python
#include <boost/python/object.hpp>
#include <pxr/pxr.h>
#include <pxr/base/tf/token.h>
#include <pxr/base/tf/diagnosticMgr.h>
#include <pxr/base/trace/reporter.h>
#include <pxr/base/trace/trace.h>
#include <pxr/base/vt/array.h>
#include <pxr/base/gf/range3f.h>
#include <pxr/base/gf/rotation.h>
#include <pxr/usd/usd/attribute.h>
#include <pxr/usd/usd/notice.h>
#include <pxr/usd/usd/stage.h>
#include <pxr/usd/usd/primRange.h>
#include <pxr/usd/usd/modelAPI.h>
#include <pxr/usd/usd/clipsAPI.h>
#include <pxr/usd/usd/inherits.h>
#include <pxr/usd/usdGeom/mesh.h>
#include <pxr/usd/usdGeom/points.h>
#include <pxr/usd/usdGeom/sphere.h>
#include <pxr/usd/usdGeom/cylinder.h>
#include <pxr/usd/usdGeom/cone.h>
#include <pxr/usd/usdGeom/xform.h>
#include <pxr/usd/usdGeom/pointInstancer.h>
#include <pxr/usd/usdGeom/primvarsAPI.h>
#include <pxr/usd/usdGeom/basisCurves.h>
#include <pxr/usd/usdGeom/camera.h>
#include <pxr/usd/usdGeom/scope.h>
#include <pxr/usd/usdVol/volume.h>
#include <pxr/usd/usdVol/openVDBAsset.h>
#include <pxr/usd/sdf/layer.h>
#include <pxr/usd/sdf/path.h>
#include <pxr/usd/usdShade/material.h>
#include <pxr/usd/usdShade/materialBindingAPI.h>
#include <pxr/usd/kind/registry.h>
#pragma warning(pop)
| 1,825 | C | 36.265305 | 85 | 0.753425 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeUsdWriter.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeUsdWriter.h"
#include "UsdBridgeCaches.h"
#include "UsdBridgeMdlStrings.h"
#include "UsdBridgeUsdWriter_Common.h"
#include "UsdBridgeDiagnosticMgrDelegate.h"
TF_DEFINE_PUBLIC_TOKENS(
UsdBridgeTokens,
ATTRIB_TOKEN_SEQ
USDPREVSURF_TOKEN_SEQ
USDPREVSURF_INPUT_TOKEN_SEQ
MDL_TOKEN_SEQ
MDL_INPUT_TOKEN_SEQ
VOLUME_TOKEN_SEQ
INDEX_TOKEN_SEQ
MISC_TOKEN_SEQ
);
namespace constring
{
const char* const sessionPf = "Session_";
const char* const rootClassName = "/RootClass";
const char* const rootPrimName = "/Root";
const char* const manifestFolder = "manifests/";
const char* const clipFolder = "clips/";
const char* const primStageFolder = "primstages/";
const char* const imgFolder = "images/";
const char* const volFolder = "volumes/";
const char* const texCoordReaderPrimPf = "texcoordreader";
const char* const psShaderPrimPf = "psshader";
const char* const mdlShaderPrimPf = "mdlshader";
const char* const psSamplerPrimPf = "pssampler";
const char* const mdlSamplerPrimPf = "mdlsampler";
const char* const mdlOpacityMulPrimPf = "opacitymul_mdl";
const char* const mdlDiffuseOpacityPrimPf = "diffuseopacity_mdl";
const char* const mdlGraphXYZPrimPf = "_xyz_f";
const char* const mdlGraphColorPrimPf = "_ftocolor";
const char* const mdlGraphXPrimPf = "_x";
const char* const mdlGraphYPrimPf = "_y";
const char* const mdlGraphZPrimPf = "_z";
const char* const mdlGraphWPrimPf = "_w";
const char* const openVDBPrimPf = "ovdbfield";
const char* const protoShapePf = "proto_";
const char* const imageExtension = ".png";
const char* const vdbExtension = ".vdb";
const char* const fullSceneNameBin = "FullScene.usd";
const char* const fullSceneNameAscii = "FullScene.usda";
const char* const mdlShaderAssetName = "OmniPBR.mdl";
const char* const mdlSupportAssetName = "nvidia/support_definitions.mdl";
const char* const mdlAuxAssetName = "nvidia/aux_definitions.mdl";
#ifdef CUSTOM_PBR_MDL
const char* const mdlFolder = "mdls/";
const char* const opaqueMaterialFile = "PBR_Opaque.mdl";
const char* const transparentMaterialFile = "PBR_Transparent.mdl";
#endif
#ifdef USE_INDEX_MATERIALS
const char* const indexMaterialPf = "indexmaterial";
const char* const indexShaderPf = "indexshader";
const char* const indexColorMapPf = "indexcolormap";
#endif
}
#define ATTRIB_TOKENS_ADD(r, data, elem) AttributeTokens.push_back(UsdBridgeTokens->elem);
UsdBridgeUsdWriter::UsdBridgeUsdWriter(const UsdBridgeSettings& settings)
: Settings(settings)
, VolumeWriter(Create_VolumeWriter(), std::mem_fn(&UsdBridgeVolumeWriterI::Release))
{
// Initialize AttributeTokens with common known attribute names
BOOST_PP_SEQ_FOR_EACH(ATTRIB_TOKENS_ADD, ~, ATTRIB_TOKEN_SEQ)
if(Settings.HostName)
ConnectionSettings.HostName = Settings.HostName;
if(Settings.OutputPath)
ConnectionSettings.WorkingDirectory = Settings.OutputPath;
FormatDirName(ConnectionSettings.WorkingDirectory);
}
UsdBridgeUsdWriter::~UsdBridgeUsdWriter()
{
}
void UsdBridgeUsdWriter::SetExternalSceneStage(UsdStageRefPtr sceneStage)
{
this->ExternalSceneStage = sceneStage;
}
void UsdBridgeUsdWriter::SetEnableSaving(bool enableSaving)
{
this->EnableSaving = enableSaving;
}
int UsdBridgeUsdWriter::FindSessionNumber()
{
int sessionNr = Connect->MaxSessionNr();
sessionNr = std::max(0, sessionNr + Settings.CreateNewSession);
return sessionNr;
}
bool UsdBridgeUsdWriter::CreateDirectories()
{
bool valid = true;
valid = Connect->CreateFolder("", true, true);
//Connect->RemoveFolder(SessionDirectory.c_str(), true, true);
bool folderMayExist = !Settings.CreateNewSession;
valid = valid && Connect->CreateFolder(SessionDirectory.c_str(), true, folderMayExist);
#ifdef VALUE_CLIP_RETIMING
valid = valid && Connect->CreateFolder((SessionDirectory + constring::manifestFolder).c_str(), true, folderMayExist);
valid = valid && Connect->CreateFolder((SessionDirectory + constring::primStageFolder).c_str(), true, folderMayExist);
#endif
#ifdef TIME_CLIP_STAGES
valid = valid && Connect->CreateFolder((SessionDirectory + constring::clipFolder).c_str(), true, folderMayExist);
#endif
#ifdef CUSTOM_PBR_MDL
if(Settings.EnableMdlShader)
{
valid = valid && Connect->CreateFolder((SessionDirectory + constring::mdlFolder).c_str(), true, folderMayExist);
}
#endif
valid = valid && Connect->CreateFolder((SessionDirectory + constring::imgFolder).c_str(), true, folderMayExist);
valid = valid && Connect->CreateFolder((SessionDirectory + constring::volFolder).c_str(), true, folderMayExist);
if (!valid)
{
UsdBridgeLogMacro(this->LogObject, UsdBridgeLogLevel::ERR, "Something went wrong in the filesystem creating the required output folders (permissions?).");
}
return valid;
}
#ifdef CUSTOM_PBR_MDL
namespace
{
void WriteMdlFromStrings(const char* string0, const char* string1, const char* fileName, const UsdBridgeConnection* Connect)
{
size_t strLen0 = std::strlen(string0);
size_t strLen1 = std::strlen(string1);
size_t totalStrLen = strLen0 + strLen1;
char* Mdl_Contents = new char[totalStrLen];
std::memcpy(Mdl_Contents, string0, strLen0);
std::memcpy(Mdl_Contents + strLen0, string1, strLen1);
Connect->WriteFile(Mdl_Contents, totalStrLen, fileName, true, false);
delete[] Mdl_Contents;
}
}
bool UsdBridgeUsdWriter::CreateMdlFiles()
{
//Write PBR opacity file contents
{
std::string relMdlPath = constring::mdlFolder + std::string(constring::opaqueMaterialFile);
this->MdlOpaqueRelFilePath = SdfAssetPath(relMdlPath);
std::string mdlFileName = SessionDirectory + relMdlPath;
WriteMdlFromStrings(Mdl_PBRBase_string, Mdl_PBRBase_string_opaque, mdlFileName.c_str(), Connect.get());
}
{
std::string relMdlPath = constring::mdlFolder + std::string(constring::transparentMaterialFile);
this->MdlTranslucentRelFilePath = SdfAssetPath(relMdlPath);
std::string mdlFileName = SessionDirectory + relMdlPath;
WriteMdlFromStrings(Mdl_PBRBase_string, Mdl_PBRBase_string_translucent, mdlFileName.c_str(), Connect.get());
}
return true;
}
#endif
bool UsdBridgeUsdWriter::InitializeSession()
{
if (ConnectionSettings.HostName.empty())
{
if(ConnectionSettings.WorkingDirectory.compare("void") == 0)
Connect = std::make_unique<UsdBridgeVoidConnection>();
else
Connect = std::make_unique<UsdBridgeLocalConnection>();
}
else
Connect = std::make_unique<UsdBridgeRemoteConnection>();
Connect->Initialize(ConnectionSettings, this->LogObject);
SessionNumber = FindSessionNumber();
SessionDirectory = constring::sessionPf + std::to_string(SessionNumber) + "/";
bool valid = true;
valid = CreateDirectories();
valid = valid && VolumeWriter->Initialize(this->LogObject);
#ifdef CUSTOM_PBR_MDL
if(Settings.EnableMdlShader)
{
valid = valid && CreateMdlFiles();
}
#endif
return valid;
}
void UsdBridgeUsdWriter::ResetSession()
{
this->SessionNumber = -1;
this->SceneStage = nullptr;
}
bool UsdBridgeUsdWriter::OpenSceneStage()
{
bool binary = this->Settings.BinaryOutput;
this->SceneFileName = this->SessionDirectory;
this->SceneFileName += (binary ? constring::fullSceneNameBin : constring::fullSceneNameAscii);
#ifdef REPLACE_SCENE_BY_EXTERNAL_STAGE
if (this->ExternalSceneStage)
{
this->SceneStage = this->ExternalSceneStage;
}
#endif
const char* absSceneFile = Connect->GetUrl(this->SceneFileName.c_str());
if (!this->SceneStage && !Settings.CreateNewSession)
this->SceneStage = UsdStage::Open(absSceneFile);
if (!this->SceneStage)
this->SceneStage = UsdStage::CreateNew(absSceneFile);
if (!this->SceneStage)
{
UsdBridgeLogMacro(this->LogObject, UsdBridgeLogLevel::ERR, "Scene UsdStage cannot be created or opened. Maybe a filesystem issue?");
return false;
}
#ifndef REPLACE_SCENE_BY_EXTERNAL_STAGE
else if (this->ExternalSceneStage)
{
// Set the scene stage as a sublayer of the external stage
ExternalSceneStage->GetRootLayer()->InsertSubLayerPath(
this->SceneStage->GetRootLayer()->GetIdentifier());
}
#endif
this->RootClassName = constring::rootClassName;
UsdPrim rootClassPrim = this->SceneStage->CreateClassPrim(SdfPath(this->RootClassName));
assert(rootClassPrim);
this->RootName = constring::rootPrimName;
UsdPrim rootPrim = this->SceneStage->DefinePrim(SdfPath(this->RootName));
assert(rootPrim);
#ifndef REPLACE_SCENE_BY_EXTERNAL_STAGE
if (!this->ExternalSceneStage)
#endif
{
this->SceneStage->SetDefaultPrim(rootPrim);
UsdModelAPI(rootPrim).SetKind(KindTokens->assembly);
}
if(!this->SceneStage->HasAuthoredTimeCodeRange())
{
this->SceneStage->SetStartTimeCode(StartTime);
this->SceneStage->SetEndTimeCode(EndTime);
}
else
{
StartTime = this->SceneStage->GetStartTimeCode();
EndTime = this->SceneStage->GetEndTimeCode();
}
if(this->EnableSaving)
this->SceneStage->Save();
return true;
}
UsdStageRefPtr UsdBridgeUsdWriter::GetSceneStage() const
{
return this->SceneStage;
}
UsdStageRefPtr UsdBridgeUsdWriter::GetTimeVarStage(UsdBridgePrimCache* cache
#ifdef TIME_CLIP_STAGES
, bool useClipStage, const char* clipPf, double timeStep
, std::function<void (UsdStageRefPtr)> initFunc
#endif
) const
{
#ifdef VALUE_CLIP_RETIMING
#ifdef TIME_CLIP_STAGES
if (useClipStage)
{
bool exists;
UsdStageRefPtr clipStage = this->FindOrCreateClipStage(cache, clipPf, timeStep, exists).second;
if(!exists)
initFunc(clipStage);
return clipStage;
}
else
return cache->GetPrimStagePair().second;
#else
return cache->GetPrimStagePair().second;
#endif
#else
return this->SceneStage;
#endif
}
#ifdef VALUE_CLIP_RETIMING
void UsdBridgeUsdWriter::CreateManifestStage(const char* name, const char* primPostfix, UsdBridgePrimCache* cacheEntry)
{
bool binary = this->Settings.BinaryOutput;
cacheEntry->ManifestStage.first = constring::manifestFolder + std::string(name) + primPostfix + (binary ? ".usd" : ".usda");
std::string absoluteFileName = Connect->GetUrl((this->SessionDirectory + cacheEntry->ManifestStage.first).c_str());
UsdBridgeDiagnosticMgrDelegate::SetOutputEnabled(false);
cacheEntry->ManifestStage.second = UsdStage::CreateNew(absoluteFileName);
UsdBridgeDiagnosticMgrDelegate::SetOutputEnabled(true);
if (!cacheEntry->ManifestStage.second)
cacheEntry->ManifestStage.second = UsdStage::Open(absoluteFileName);
assert(cacheEntry->ManifestStage.second);
cacheEntry->ManifestStage.second->DefinePrim(SdfPath(this->RootClassName));
}
void UsdBridgeUsdWriter::RemoveManifestAndClipStages(const UsdBridgePrimCache* cacheEntry)
{
// May be superfluous
if(cacheEntry->ManifestStage.second)
{
cacheEntry->ManifestStage.second->RemovePrim(SdfPath(RootClassName));
// Remove ManifestStage file itself
assert(!cacheEntry->ManifestStage.first.empty());
Connect->RemoveFile((SessionDirectory + cacheEntry->ManifestStage.first).c_str(), true);
}
// remove all clipstage files
for (auto& x : cacheEntry->ClipStages)
{
Connect->RemoveFile((SessionDirectory + x.second.first).c_str(), true);
}
}
const UsdStagePair& UsdBridgeUsdWriter::FindOrCreatePrimStage(UsdBridgePrimCache* cacheEntry, const char* namePostfix) const
{
bool exists;
return FindOrCreatePrimClipStage(cacheEntry, namePostfix, false, UsdBridgePrimCache::PrimStageTimeCode, exists);
}
const UsdStagePair& UsdBridgeUsdWriter::FindOrCreateClipStage(UsdBridgePrimCache* cacheEntry, const char* namePostfix, double timeStep, bool& exists) const
{
return FindOrCreatePrimClipStage(cacheEntry, namePostfix, true, timeStep, exists);
}
const UsdStagePair& UsdBridgeUsdWriter::FindOrCreatePrimClipStage(UsdBridgePrimCache* cacheEntry, const char* namePostfix, bool isClip, double timeStep, bool& exists) const
{
exists = true;
bool binary = this->Settings.BinaryOutput;
auto it = cacheEntry->ClipStages.find(timeStep);
if (it == cacheEntry->ClipStages.end())
{
// Create a new Clipstage
const char* folder = constring::primStageFolder;
std::string fullNamePostfix(namePostfix);
if(isClip)
{
folder = constring::clipFolder;
fullNamePostfix += std::to_string(timeStep);
}
std::string relativeFileName = folder + cacheEntry->Name.GetString() + fullNamePostfix + (binary ? ".usd" : ".usda");
std::string absoluteFileName = Connect->GetUrl((this->SessionDirectory + relativeFileName).c_str());
UsdBridgeDiagnosticMgrDelegate::SetOutputEnabled(false);
UsdStageRefPtr primClipStage = UsdStage::CreateNew(absoluteFileName);
UsdBridgeDiagnosticMgrDelegate::SetOutputEnabled(true);
exists = !primClipStage;
SdfPath rootPrimPath(this->RootClassName);
if (exists)
{
primClipStage = UsdStage::Open(absoluteFileName); //Could happen if written folder is reused
assert(primClipStage->GetPrimAtPath(rootPrimPath));
}
else
primClipStage->DefinePrim(rootPrimPath);
it = cacheEntry->ClipStages.emplace(timeStep, UsdStagePair(std::move(relativeFileName), primClipStage)).first;
}
return it->second;
}
#endif
void UsdBridgeUsdWriter::AddRootPrim(UsdBridgePrimCache* primCache, const char* primPathCp, const char* layerId)
{
SdfPath primPath(this->RootName + "/" + primPathCp);
primPath = primPath.AppendPath(primCache->Name);
UsdPrim sceneGraphPrim = SceneStage->DefinePrim(primPath);
assert(sceneGraphPrim);
UsdReferences primRefs = sceneGraphPrim.GetReferences();
primRefs.ClearReferences();
#ifdef VALUE_CLIP_RETIMING
if(layerId)
{
primRefs.AddReference(layerId, primCache->PrimPath);
}
#endif
// Always add a ref to the internal prim, which is represented by the cache
primRefs.AddInternalReference(primCache->PrimPath);
}
void UsdBridgeUsdWriter::RemoveRootPrim(UsdBridgePrimCache* primCache, const char* primPathCp)
{
SdfPath primPath(this->RootName + "/" + primPathCp);
primPath = primPath.AppendPath(primCache->Name);
this->SceneStage->RemovePrim(primPath);
}
const std::string& UsdBridgeUsdWriter::CreatePrimName(const char * name, const char * category)
{
(this->TempNameStr = this->RootClassName).append("/").append(category).append("/").append(name);
return this->TempNameStr;
}
const std::string& UsdBridgeUsdWriter::GetResourceFileName(const std::string& basePath, double timeStep, const char* fileExtension)
{
this->TempNameStr = basePath;
#ifdef TIME_BASED_CACHING
this->TempNameStr += "_";
this->TempNameStr += std::to_string(timeStep);
#endif
this->TempNameStr += fileExtension;
return this->TempNameStr;
}
const std::string& UsdBridgeUsdWriter::GetResourceFileName(const char* folderName, const std::string& objectName, double timeStep, const char* fileExtension)
{
return GetResourceFileName(folderName + objectName, timeStep, fileExtension);
}
const std::string& UsdBridgeUsdWriter::GetResourceFileName(const char* folderName, const char* optionalObjectName, const std::string& defaultObjectName, double timeStep, const char* fileExtension)
{
return GetResourceFileName(folderName, (optionalObjectName ? std::string(optionalObjectName) : defaultObjectName), timeStep, fileExtension);
}
bool UsdBridgeUsdWriter::CreatePrim(const SdfPath& path)
{
UsdPrim classPrim = SceneStage->GetPrimAtPath(path);
if(!classPrim)
{
classPrim = SceneStage->DefinePrim(path);
assert(classPrim);
return true;
}
return false;
}
void UsdBridgeUsdWriter::DeletePrim(const UsdBridgePrimCache* cacheEntry)
{
if(SceneStage->GetPrimAtPath(cacheEntry->PrimPath))
SceneStage->RemovePrim(cacheEntry->PrimPath);
#ifdef VALUE_CLIP_RETIMING
RemoveManifestAndClipStages(cacheEntry);
#endif
}
#ifdef TIME_BASED_CACHING
void UsdBridgeUsdWriter::InitializePrimVisibility(UsdStageRefPtr stage, const SdfPath& primPath, const UsdTimeCode& timeCode,
UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache)
{
UsdGeomImageable imageable = UsdGeomImageable::Get(stage, primPath);
if (imageable)
{
UsdAttribute visAttrib = imageable.GetVisibilityAttr(); // in case MakeVisible fails
if(!visAttrib)
visAttrib = imageable.CreateVisibilityAttr(VtValue(UsdGeomTokens->invisible)); // default is invisible
double startTime = stage->GetStartTimeCode();
double endTime = stage->GetEndTimeCode();
if (startTime < timeCode)
visAttrib.Set(VtValue(UsdGeomTokens->invisible), startTime);//imageable.MakeInvisible(startTime);
if (endTime > timeCode)
visAttrib.Set(VtValue(UsdGeomTokens->invisible), endTime);//imageable.MakeInvisible(endTime);
visAttrib.Set(VtValue(UsdGeomTokens->inherited), timeCode);//imageable.MakeVisible(timeCode);
parentCache->SetChildVisibleAtTime(childCache, timeCode.GetValue());
}
}
void UsdBridgeUsdWriter::SetPrimVisible(UsdStageRefPtr stage, const SdfPath& primPath, const UsdTimeCode& timeCode,
UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache)
{
UsdGeomImageable imageable = UsdGeomImageable::Get(stage, primPath);
if (imageable)
{
UsdAttribute visAttrib = imageable.GetVisibilityAttr();
assert(visAttrib);
visAttrib.Set(VtValue(UsdGeomTokens->inherited), timeCode);//imageable.MakeVisible(timeCode);
parentCache->SetChildVisibleAtTime(childCache, timeCode.GetValue());
}
}
void UsdBridgeUsdWriter::PrimRemoveIfInvisibleAnytime(UsdStageRefPtr stage, const UsdPrim& prim, bool timeVarying, const UsdTimeCode& timeCode, AtRemoveRefFunc atRemoveRef,
UsdBridgePrimCache* parentCache, UsdBridgePrimCache* primCache)
{
const SdfPath& primPath = prim.GetPath();
bool removePrim = true; // TimeVarying is not automatically removed
if (timeVarying)
{
if(primCache)
{
// Remove prim only if there are no more visible children AND the timecode has actually been removed
// (so if the timecode wasn't found in the cache, do not remove the prim)
removePrim = parentCache->SetChildInvisibleAtTime(primCache, timeCode.GetValue());
// If prim is still visible at other times, make sure to explicitly set this timeCode as invisible
if(!removePrim)
{
UsdGeomImageable imageable = UsdGeomImageable::Get(stage, primPath);
if (imageable)
{
UsdAttribute visAttrib = imageable.GetVisibilityAttr();
if (visAttrib)
visAttrib.Set(UsdGeomTokens->invisible, timeCode);
}
}
}
else
removePrim = false; // If no cache is available, just don't remove, for possibility of previous timesteps (opposite from when !timeVarying)
}
if (removePrim)
{
// Decrease the ref on the representing cache entry
if(primCache)
atRemoveRef(parentCache, primCache);
// Remove the prim
stage->RemovePrim(primPath);
}
}
void UsdBridgeUsdWriter::ChildrenRemoveIfInvisibleAnytime(UsdStageRefPtr stage, UsdBridgePrimCache* parentCache, const SdfPath& parentPath, bool timeVarying, const UsdTimeCode& timeCode, AtRemoveRefFunc atRemoveRef, const SdfPath& exceptPath)
{
UsdPrim parentPrim = stage->GetPrimAtPath(parentPath);
if (parentPrim)
{
UsdPrimSiblingRange children = parentPrim.GetAllChildren();
for (UsdPrim child : children)
{
UsdBridgePrimCache* childCache = parentCache->GetChildCache(child.GetName());
if (child.GetPath() != exceptPath)
PrimRemoveIfInvisibleAnytime(stage, child, timeVarying, timeCode, atRemoveRef,
parentCache, childCache);
}
}
}
#endif
#ifdef VALUE_CLIP_RETIMING
void UsdBridgeUsdWriter::InitializeClipMetaData(const UsdPrim& clipPrim, UsdBridgePrimCache* childCache, double parentTimeStep, double childTimeStep, bool clipStages, const char* clipPostfix)
{
UsdClipsAPI clipsApi(clipPrim);
clipsApi.SetClipPrimPath(childCache->PrimPath.GetString());
const std::string& manifestPath = childCache->ManifestStage.first;
const std::string* refStagePath;
#ifdef TIME_CLIP_STAGES
if (clipStages)
{
//set interpolatemissingclipvalues?
bool exists;
const UsdStagePair& childStagePair = FindOrCreateClipStage(childCache, clipPostfix, childTimeStep, exists);
//assert(exists); // In case prim creation succeeds but an update is not attempted, no clip stage is generated, so exists will be false
if(!exists)
UsdBridgeLogMacro(this->LogObject, UsdBridgeLogLevel::WARNING, "Child clip stage not found while setting clip metadata, using generated stage instead. Probably the child data has not been properly updated.");
refStagePath = &childStagePair.first;
}
else
#endif
{
refStagePath = &childCache->GetPrimStagePair().first;
}
clipsApi.SetClipManifestAssetPath(SdfAssetPath(manifestPath));
VtArray<SdfAssetPath> assetPaths;
assetPaths.push_back(SdfAssetPath(*refStagePath));
clipsApi.SetClipAssetPaths(assetPaths);
VtVec2dArray clipActives;
clipActives.push_back(GfVec2d(parentTimeStep, 0));
clipsApi.SetClipActive(clipActives);
VtVec2dArray clipTimes;
clipTimes.push_back(GfVec2d(parentTimeStep, childTimeStep));
clipsApi.SetClipTimes(clipTimes);
}
void UsdBridgeUsdWriter::UpdateClipMetaData(const UsdPrim& clipPrim, UsdBridgePrimCache* childCache, double parentTimeStep, double childTimeStep, bool clipStages, const char* clipPostfix)
{
// Add parent-child timestep or update existing relationship
UsdClipsAPI clipsApi(clipPrim);
#ifdef TIME_CLIP_STAGES
if (clipStages)
{
bool exists;
const UsdStagePair& childStagePair = FindOrCreateClipStage(childCache, clipPostfix, childTimeStep, exists);
// At this point, exists should be true, but if clip stage creation failed earlier due to user error,
// exists will be false and we'll just link to the empty new stage created by FindOrCreatePrimClipStage()
const std::string& refStagePath = childStagePair.first;
VtVec2dArray clipActives;
clipsApi.GetClipActive(&clipActives);
VtArray<SdfAssetPath> assetPaths;
clipsApi.GetClipAssetPaths(&assetPaths);
// Find the asset path
SdfAssetPath refStageSdf(refStagePath);
auto assetIt = std::find_if(assetPaths.begin(), assetPaths.end(), [&refStageSdf](const SdfAssetPath& entry) -> bool { return refStageSdf.GetAssetPath() == entry.GetAssetPath(); });
int assetIndex = int(assetIt - assetPaths.begin());
bool newAsset = (assetIndex == assetPaths.size()); // Gives the opportunity to garbage collect unused asset references
{
// Find the parentTimeStep
int timeFindIdx = 0;
for (; timeFindIdx < clipActives.size() && clipActives[timeFindIdx][0] != parentTimeStep; ++timeFindIdx)
{}
bool replaceAsset = false;
// If timestep not found, just add (time, asset ref idx) to actives
if (timeFindIdx == clipActives.size())
clipActives.push_back(GfVec2d(parentTimeStep, assetIndex));
else
{
// Find out whether to update existing active entry with new asset ref idx, or let the entry unchanged and replace the asset itself
double prevAssetIndex = clipActives[timeFindIdx][1];
if (newAsset)
{
//Find prev asset index
int assetIdxFindIdx = 0;
for (; assetIdxFindIdx < clipActives.size() &&
(assetIdxFindIdx == timeFindIdx || clipActives[assetIdxFindIdx][1] != prevAssetIndex);
++assetIdxFindIdx)
{}
// replacement occurs when prevAssetIndex hasn't been found in other entries
replaceAsset = (assetIdxFindIdx == clipActives.size());
}
if(replaceAsset)
assetPaths[int(prevAssetIndex)] = refStageSdf;
else
clipActives[timeFindIdx][1] = assetIndex;
}
// If new asset and not put in place of an old asset, add to assetPaths
if (newAsset && !replaceAsset)
assetPaths.push_back(refStageSdf);
// Send the result through to usd
clipsApi.SetClipAssetPaths(assetPaths);
clipsApi.SetClipActive(clipActives);
}
}
#endif
// Find the parentTimeStep, and change its child (or add the pair if nonexistent)
VtVec2dArray clipTimes;
clipsApi.GetClipTimes(&clipTimes);
{
int findIdx = 0;
for (; findIdx < clipTimes.size(); ++findIdx)
{
if (clipTimes[findIdx][0] == parentTimeStep)
{
clipTimes[findIdx][1] = childTimeStep;
break;
}
}
if (findIdx == clipTimes.size())
clipTimes.push_back(GfVec2d(parentTimeStep, childTimeStep));
clipsApi.SetClipTimes(clipTimes);
}
}
#endif
SdfPath UsdBridgeUsdWriter::AddRef_NoClip(UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache, const char* refPathExt,
bool timeVarying, double parentTimeStep, bool instanceable,
const RefModFuncs& refModCallbacks)
{
return AddRef_Impl(parentCache, childCache, refPathExt, timeVarying, false, false, nullptr, parentTimeStep, parentTimeStep, instanceable, refModCallbacks);
}
SdfPath UsdBridgeUsdWriter::AddRef(UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache, const char* refPathExt,
bool timeVarying, bool valueClip, bool clipStages, const char* clipPostfix,
double parentTimeStep, double childTimeStep, bool instanceable,
const RefModFuncs& refModCallbacks)
{
// Value clip-enabled references have to be defined on the scenestage, as usd does not re-time recursively.
return AddRef_Impl(parentCache, childCache, refPathExt, timeVarying, valueClip, clipStages, clipPostfix, parentTimeStep, childTimeStep, instanceable, refModCallbacks);
}
SdfPath UsdBridgeUsdWriter::AddRef_Impl(UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache, const char* refPathExt,
bool timeVarying, // Timevarying existence (visible or not) of the reference itself
bool valueClip, // Retiming through a value clip
bool clipStages, // Separate stages for separate time slots (can only exist in usd if valueClip enabled)
const char* clipPostfix, double parentTimeStep, double childTimeStep, bool instanceable,
const RefModFuncs& refModCallbacks)
{
UsdTimeCode parentTimeCode(parentTimeStep);
SdfPath childBasePath = parentCache->PrimPath;
if (refPathExt)
childBasePath = parentCache->PrimPath.AppendPath(SdfPath(refPathExt));
SdfPath referencingPrimPath = childBasePath.AppendPath(childCache->Name);
UsdPrim referencingPrim = SceneStage->GetPrimAtPath(referencingPrimPath);
if (!referencingPrim)
{
referencingPrim = SceneStage->DefinePrim(referencingPrimPath);
assert(referencingPrim);
#ifdef VALUE_CLIP_RETIMING
if (valueClip)
InitializeClipMetaData(referencingPrim, childCache, parentTimeStep, childTimeStep, clipStages, clipPostfix);
#endif
{
UsdReferences references = referencingPrim.GetReferences(); //references or inherits?
references.ClearReferences();
references.AddInternalReference(childCache->PrimPath);
//referencingPrim.SetInstanceable(true);
}
refModCallbacks.AtNewRef(parentCache, childCache);
#ifdef TIME_BASED_CACHING
// If time domain of the stage extends beyond timestep in either direction, set visibility false for extremes.
if (timeVarying)
InitializePrimVisibility(SceneStage, referencingPrimPath, parentTimeCode,
parentCache, childCache);
#endif
}
else
{
#ifdef TIME_BASED_CACHING
if (timeVarying)
SetPrimVisible(SceneStage, referencingPrimPath, parentTimeCode,
parentCache, childCache);
#ifdef VALUE_CLIP_RETIMING
// Cliptimes are added as additional info, not actively removed (visibility values remain leading in defining existing relationships over timesteps)
// Also, clip stages at childTimeSteps which are not referenced anymore, are not removed; they could still be referenced from other parents!
if (valueClip)
UpdateClipMetaData(referencingPrim, childCache, parentTimeStep, childTimeStep, clipStages, clipPostfix);
#endif
#endif
}
referencingPrim.SetInstanceable(instanceable);
return referencingPrimPath;
}
void UsdBridgeUsdWriter::RemoveAllRefs(UsdBridgePrimCache* parentCache, const char* refPathExt, bool timeVarying, double timeStep, AtRemoveRefFunc atRemoveRef)
{
SdfPath childBasePath = parentCache->PrimPath;
if (refPathExt)
childBasePath = parentCache->PrimPath.AppendPath(SdfPath(refPathExt));
RemoveAllRefs(SceneStage, parentCache, childBasePath, timeVarying, timeStep, atRemoveRef);
}
void UsdBridgeUsdWriter::RemoveAllRefs(UsdStageRefPtr stage, UsdBridgePrimCache* parentCache, SdfPath childBasePath, bool timeVarying, double timeStep, AtRemoveRefFunc atRemoveRef)
{
#ifdef TIME_BASED_CACHING
UsdTimeCode timeCode(timeStep);
// Make refs just for this timecode invisible and possibly remove,
// but leave refs which are still visible in other timecodes intact.
ChildrenRemoveIfInvisibleAnytime(stage, parentCache, childBasePath, timeVarying, timeCode, atRemoveRef);
#else
UsdPrim parentPrim = stage->GetPrimAtPath(childBasePath);
if(parentPrim)
{
UsdPrimSiblingRange children = parentPrim.GetAllChildren();
for (UsdPrim child : children)
{
UsdBridgePrimCache* childCache = parentCache->GetChildCache(child.GetName());
if(childCache)
{
atRemoveRef(parentCache, childCache); // Decrease reference count in caches
stage->RemovePrim(child.GetPath()); // Remove reference prim
}
}
}
#endif
}
void UsdBridgeUsdWriter::ManageUnusedRefs(UsdBridgePrimCache* parentCache, const UsdBridgePrimCacheList& newChildren, const char* refPathExt, bool timeVarying, double timeStep, AtRemoveRefFunc atRemoveRef)
{
ManageUnusedRefs(SceneStage, parentCache, newChildren, refPathExt, timeVarying, timeStep, atRemoveRef);
}
void UsdBridgeUsdWriter::ManageUnusedRefs(UsdStageRefPtr stage, UsdBridgePrimCache* parentCache, const UsdBridgePrimCacheList& newChildren, const char* refPathExt, bool timeVarying, double timeStep, AtRemoveRefFunc atRemoveRef)
{
UsdTimeCode timeCode(timeStep);
UsdPrim basePrim;
if (refPathExt)
{
SdfPath childBasePath = parentCache->PrimPath.AppendPath(SdfPath(refPathExt));
basePrim = stage->GetPrimAtPath(childBasePath);
}
else
basePrim = stage->GetPrimAtPath(parentCache->PrimPath);
if (basePrim)
{
// For each old (referencing) child prim, find it among the new ones, otherwise
// possibly delete the referencing prim.
UsdPrimSiblingRange children = basePrim.GetAllChildren();
for (UsdPrim oldChild : children)
{
bool found = false;
for (size_t newChildIdx = 0; newChildIdx < newChildren.size() && !found; ++newChildIdx)
{
found = (oldChild.GetName() == newChildren[newChildIdx]->PrimPath.GetNameToken());
}
UsdBridgePrimCache* oldChildCache = parentCache->GetChildCache(oldChild.GetName());
// Not an assert: allow the case where child prims in a stage aren't cached, ie. when the bridge is destroyed and recreated
if (!found)
#ifdef TIME_BASED_CACHING
{
// Remove *referencing* prim if no visible timecode exists anymore
PrimRemoveIfInvisibleAnytime(stage, oldChild, timeVarying, timeCode, atRemoveRef,
parentCache, oldChildCache);
}
#else
{// remove the whole referencing prim
if(oldChildCache)
atRemoveRef(parentCache, oldChildCache);
stage->RemovePrim(oldChild.GetPath());
}
#endif
}
}
}
void UsdBridgeUsdWriter::InitializeUsdTransform(const UsdBridgePrimCache* cacheEntry)
{
SdfPath transformPath = cacheEntry->PrimPath;
UsdGeomXform transform = GetOrDefinePrim<UsdGeomXform>(SceneStage, transformPath);
assert(transform);
}
void UsdBridgeUsdWriter::InitializeUsdCamera(UsdStageRefPtr cameraStage, const SdfPath& cameraPath)
{
UsdGeomCamera cameraPrim = GetOrDefinePrim<UsdGeomCamera>(cameraStage, cameraPath);
assert(cameraPrim);
cameraPrim.CreateProjectionAttr();
cameraPrim.CreateHorizontalApertureAttr();
cameraPrim.CreateVerticalApertureAttr();
cameraPrim.CreateFocalLengthAttr();
cameraPrim.CreateClippingRangeAttr();
}
void UsdBridgeUsdWriter::BindMaterialToGeom(const SdfPath & refGeomPath, const SdfPath & refMatPath)
{
UsdPrim refGeomPrim = this->SceneStage->GetPrimAtPath(refGeomPath);
assert(refGeomPrim);
// Bind the material to the mesh (use paths existing fully within the surface class definition, not the inherited geometry/material)
UsdShadeMaterial refMatPrim = UsdShadeMaterial::Get(this->SceneStage, refMatPath);
assert(refMatPrim);
UsdShadeMaterialBindingAPI(refGeomPrim).Bind(refMatPrim);
}
void UsdBridgeUsdWriter::UnbindMaterialFromGeom(const SdfPath & refGeomPath)
{
UsdPrim refGeomPrim = this->SceneStage->GetPrimAtPath(refGeomPath);
assert(refGeomPrim);
UsdShadeMaterialBindingAPI(refGeomPrim).UnbindDirectBinding();
}
void UsdBridgeUsdWriter::UpdateUsdTransform(const SdfPath& transPrimPath, const float* transform, bool timeVarying, double timeStep)
{
TimeEvaluator<bool> timeEval(timeVarying, timeStep);
// Note: USD employs left-multiplication (vector in row-space)
GfMatrix4d transMat; // Transforms can only be double, see UsdGeomXform::AddTransformOp (UsdGeomXformable)
transMat.SetRow(0, GfVec4d(GfVec4f(&transform[0])));
transMat.SetRow(1, GfVec4d(GfVec4f(&transform[4])));
transMat.SetRow(2, GfVec4d(GfVec4f(&transform[8])));
transMat.SetRow(3, GfVec4d(GfVec4f(&transform[12])));
//Note that instance transform nodes have already been created.
UsdGeomXform tfPrim = UsdGeomXform::Get(this->SceneStage, transPrimPath);
assert(tfPrim);
tfPrim.ClearXformOpOrder();
UsdGeomXformOp xformOp = tfPrim.AddTransformOp();
ClearAndSetUsdAttribute(xformOp.GetAttr(), transMat, timeEval.Eval(), !timeEval.TimeVarying);
}
void UsdBridgeUsdWriter::UpdateUsdCamera(UsdStageRefPtr timeVarStage, const SdfPath& cameraPrimPath,
const UsdBridgeCameraData& cameraData, double timeStep, bool timeVarHasChanged)
{
const TimeEvaluator<UsdBridgeCameraData> timeEval(cameraData, timeStep);
typedef UsdBridgeCameraData::DataMemberId DMI;
UsdGeomCamera cameraPrim = UsdGeomCamera::Get(timeVarStage, cameraPrimPath);
assert(cameraPrim);
// Set the view matrix
GfVec3d eyePoint(cameraData.Position.Data);
GfVec3d fwdDir(cameraData.Direction.Data);
GfVec3d upDir(cameraData.Up.Data);
GfVec3d lookAtPoint = eyePoint+fwdDir;
GfMatrix4d viewMatrix;
viewMatrix.SetLookAt(eyePoint, lookAtPoint, upDir);
cameraPrim.ClearXformOpOrder();
UsdGeomXformOp xformOp = cameraPrim.AddTransformOp();
ClearAndSetUsdAttribute(xformOp.GetAttr(), viewMatrix, timeEval.Eval(DMI::VIEW),
timeVarHasChanged && !timeEval.IsTimeVarying(DMI::VIEW));
// Helper function for the projection matrix
GfCamera gfCam;
gfCam.SetPerspectiveFromAspectRatioAndFieldOfView(cameraData.Aspect, cameraData.Fovy, GfCamera::FOVVertical);
// Update all attributes affected by SetPerspectiveFromAspectRatioAndFieldOfView (see implementation)
UsdTimeCode projectTime = timeEval.Eval(DMI::PROJECTION);
bool clearProjAttrib = timeVarHasChanged && !timeEval.IsTimeVarying(DMI::PROJECTION);
ClearAndSetUsdAttribute(cameraPrim.GetProjectionAttr(),
gfCam.GetProjection() == GfCamera::Perspective ?
UsdGeomTokens->perspective : UsdGeomTokens->orthographic,
projectTime, clearProjAttrib);
ClearAndSetUsdAttribute(cameraPrim.GetHorizontalApertureAttr(), gfCam.GetHorizontalAperture(), projectTime, clearProjAttrib);
ClearAndSetUsdAttribute(cameraPrim.GetVerticalApertureAttr(), gfCam.GetVerticalAperture(), projectTime, clearProjAttrib);
ClearAndSetUsdAttribute(cameraPrim.GetFocalLengthAttr(), gfCam.GetFocalLength(), projectTime, clearProjAttrib);
ClearAndSetUsdAttribute(cameraPrim.GetClippingRangeAttr(), GfVec2f(cameraData.Near, cameraData.Far), projectTime, clearProjAttrib);
}
void UsdBridgeUsdWriter::UpdateBeginEndTime(double timeStep)
{
if (timeStep < StartTime)
{
StartTime = timeStep;
SceneStage->SetStartTimeCode(timeStep);
}
if (timeStep > EndTime)
{
EndTime = timeStep;
SceneStage->SetEndTimeCode(timeStep);
}
}
TfToken& UsdBridgeUsdWriter::AttributeNameToken(const char* attribName)
{
int i = 0;
for(; i < AttributeTokens.size(); ++i)
{
if(AttributeTokens[i] == attribName) // Overloaded == operator on TfToken
break;
}
if(i == AttributeTokens.size())
AttributeTokens.emplace_back(TfToken(attribName));
return AttributeTokens[i];
}
void UsdBridgeUsdWriter::AddSharedResourceRef(const UsdBridgeResourceKey& key)
{
bool found = false;
for(auto& entry : SharedResourceCache)
{
if(entry.first == key)
{
++entry.second.first;
found = true;
}
}
if(!found)
SharedResourceCache.push_back(SharedResourceKV(key, SharedResourceValue(1, false)));
}
bool UsdBridgeUsdWriter::RemoveSharedResourceRef(const UsdBridgeResourceKey& key)
{
bool removed = false;
SharedResourceContainer::iterator it = SharedResourceCache.begin();
while(it != SharedResourceCache.end())
{
if(it->first == key)
--it->second.first;
if(it->second.first == 0)
{
it = SharedResourceCache.erase(it);
removed = true;
}
else
++it;
}
return removed;
}
bool UsdBridgeUsdWriter::SetSharedResourceModified(const UsdBridgeResourceKey& key)
{
bool modified = false;
for(auto& entry : SharedResourceCache)
{
if(entry.first == key)
{
modified = entry.second.second;
entry.second.second = true;
}
}
return modified;
}
void UsdBridgeUsdWriter::ResetSharedResourceModified()
{
for(auto& entry : SharedResourceCache)
{
entry.second.second = false;
}
}
void RemoveResourceFiles(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter,
const char* resourceFolder, const char* fileExtension)
{
// Directly from usd is inaccurate, as timesteps may have been cleared without file removal
//// Assuming prim without clip stages.
//const UsdStageRefPtr volumeStage = usdWriter.GetTimeVarStage(cache);
//const UsdStageRefPtr volumeStage = usdWriter.GetTimeVarStage(cache);
//const SdfPath& volPrimPath = cache->PrimPath;
//
//UsdVolVolume volume = UsdVolVolume::Get(volumeStage, volPrimPath);
//assert(volume);
//
//SdfPath ovdbFieldPath = volPrimPath.AppendPath(SdfPath(constring::openVDBPrimPf));
//UsdVolOpenVDBAsset ovdbField = UsdVolOpenVDBAsset::Get(volumeStage, ovdbFieldPath);
//
//UsdAttribute fileAttr = ovdbField.GetFilePathAttr();
//
//std::vector<double> fileTimes;
//fileAttr.GetTimeSamples(&fileTimes);
assert(cache->ResourceKeys);
UsdBridgePrimCache::ResourceContainer& keys = *(cache->ResourceKeys);
std::string basePath = usdWriter.SessionDirectory; basePath.append(resourceFolder);
for (const UsdBridgeResourceKey& key : keys)
{
bool removeFile = true;
if(key.name)
removeFile = usdWriter.RemoveSharedResourceRef(key);
if(removeFile)
{
double timeStep =
#ifdef TIME_BASED_CACHING
key.timeStep;
#else
0.0;
#endif
const std::string& resFileName = usdWriter.GetResourceFileName(basePath.c_str(), key.name, timeStep, fileExtension);
usdWriter.Connect->RemoveFile(resFileName.c_str(), true);
}
}
keys.resize(0);
} | 39,261 | C++ | 33.806738 | 242 | 0.744912 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeUsdWriter.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeUsdWriter_h
#define UsdBridgeUsdWriter_h
#include "usd.h"
PXR_NAMESPACE_USING_DIRECTIVE
#include "UsdBridgeData.h"
#include "UsdBridgeCaches.h"
#include "UsdBridgeVolumeWriter.h"
#include "UsdBridgeConnection.h"
#include "UsdBridgeTimeEvaluator.h"
#include <memory>
#include <functional>
//Includes detailed usd translation interface of Usd Bridge
class UsdBridgeUsdWriter
{
public:
using MaterialDMI = UsdBridgeMaterialData::DataMemberId;
using SamplerDMI = UsdBridgeSamplerData::DataMemberId;
using AtNewRefFunc = std::function<void(UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache)>;
using AtRemoveRefFunc = std::function<void(UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache)>;
struct RefModFuncs
{
AtNewRefFunc AtNewRef;
AtRemoveRefFunc AtRemoveRef;
};
UsdBridgeUsdWriter(const UsdBridgeSettings& settings);
~UsdBridgeUsdWriter();
void SetExternalSceneStage(UsdStageRefPtr sceneStage);
void SetEnableSaving(bool enableSaving);
int FindSessionNumber();
bool CreateDirectories();
#ifdef CUSTOM_PBR_MDL
bool CreateMdlFiles();
#endif
bool InitializeSession();
void ResetSession();
bool OpenSceneStage();
UsdStageRefPtr GetSceneStage() const;
UsdStageRefPtr GetTimeVarStage(UsdBridgePrimCache* cache
#ifdef TIME_CLIP_STAGES
, bool useClipStage = false, const char* clipPf = nullptr, double timeStep = 0.0
, std::function<void (UsdStageRefPtr)> initFunc = [](UsdStageRefPtr){}
#endif
) const;
#ifdef VALUE_CLIP_RETIMING
void CreateManifestStage(const char* name, const char* primPostfix, UsdBridgePrimCache* cacheEntry);
void RemoveManifestAndClipStages(const UsdBridgePrimCache* cacheEntry);
const UsdStagePair& FindOrCreatePrimStage(UsdBridgePrimCache* cacheEntry, const char* namePostfix) const;
const UsdStagePair& FindOrCreateClipStage(UsdBridgePrimCache* cacheEntry, const char* namePostfix, double timeStep, bool& exists) const;
const UsdStagePair& FindOrCreatePrimClipStage(UsdBridgePrimCache* cacheEntry, const char* namePostfix, bool isClip, double timeStep, bool& exists) const;
#endif
void AddRootPrim(UsdBridgePrimCache* primCache, const char* primPathCp, const char* layerId = nullptr);
void RemoveRootPrim(UsdBridgePrimCache* primCache, const char* primPathCp);
const std::string& CreatePrimName(const char* name, const char* category);
const std::string& GetResourceFileName(const std::string& basePath, double timeStep, const char* fileExtension);
const std::string& GetResourceFileName(const char* folderName, const std::string& objectName, double timeStep, const char* fileExtension);
const std::string& GetResourceFileName(const char* folderName, const char* optionalObjectName, const std::string& defaultObjectName, double timeStep, const char* fileExtension);
bool CreatePrim(const SdfPath& path);
void DeletePrim(const UsdBridgePrimCache* cacheEntry);
#ifdef TIME_BASED_CACHING
void InitializePrimVisibility(UsdStageRefPtr stage, const SdfPath& primPath, const UsdTimeCode& timeCode,
UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache);
void SetPrimVisible(UsdStageRefPtr stage, const SdfPath& primPath, const UsdTimeCode& timeCode,
UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache);
void PrimRemoveIfInvisibleAnytime(UsdStageRefPtr stage, const UsdPrim& prim, bool timeVarying, const UsdTimeCode& timeCode, AtRemoveRefFunc atRemoveRef,
UsdBridgePrimCache* parentCache, UsdBridgePrimCache* primCache);
void ChildrenRemoveIfInvisibleAnytime(UsdStageRefPtr stage, UsdBridgePrimCache* parentCache, const SdfPath& parentPath, bool timeVarying, const UsdTimeCode& timeCode, AtRemoveRefFunc atRemoveRef, const SdfPath& exceptPath = SdfPath());
#endif
#ifdef VALUE_CLIP_RETIMING
void InitializeClipMetaData(const UsdPrim& clipPrim, UsdBridgePrimCache* childCache, double parentTimeStep, double childTimeStep, bool clipStages, const char* clipPostfix);
void UpdateClipMetaData(const UsdPrim& clipPrim, UsdBridgePrimCache* childCache, double parentTimeStep, double childTimeStep, bool clipStages, const char* clipPostfix);
#endif
SdfPath AddRef_NoClip(UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache, const char* refPathExt,
bool timeVarying, double parentTimeStep, bool instanceable,
const RefModFuncs& refModCallbacks);
SdfPath AddRef(UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache, const char* refPathExt,
bool timeVarying, bool valueClip, bool clipStages, const char* clipPostFix,
double parentTimeStep, double childTimeStep, bool instanceable,
const RefModFuncs& refModCallbacks);
// Timevarying means that the existence of a reference between prim A and B can differ over time, valueClip denotes the addition of clip metadata for re-timing,
// and clipStages will carve up the referenced clip asset files into one for each timestep (stages are created as necessary). clipPostFix is irrelevant if !clipStages.
// Returns the path to the parent's subprim which represents/holds the reference to the child's main class prim.
SdfPath AddRef_Impl(UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache, const char* refPathExt,
bool timeVarying, bool valueClip, bool clipStages, const char* clipPostFix,
double parentTimeStep, double childTimeStep, bool instanceable,
const RefModFuncs& refModCallbacks);
void RemoveAllRefs(UsdBridgePrimCache* parentCache, const char* refPathExt, bool timeVarying, double timeStep, AtRemoveRefFunc atRemoveRef);
void RemoveAllRefs(UsdStageRefPtr stage, UsdBridgePrimCache* parentCache, SdfPath childBasePath, bool timeVarying, double timeStep, AtRemoveRefFunc atRemoveRef);
void ManageUnusedRefs(UsdBridgePrimCache* parentCache, const UsdBridgePrimCacheList& newChildren, const char* refPathExt, bool timeVarying, double timeStep, AtRemoveRefFunc atRemoveRef);
void ManageUnusedRefs(UsdStageRefPtr stage, UsdBridgePrimCache* parentCache, const UsdBridgePrimCacheList& newChildren, const char* refPathExt, bool timeVarying, double timeStep, AtRemoveRefFunc atRemoveRef);
void InitializeUsdTransform(const UsdBridgePrimCache* cacheEntry);
UsdPrim InitializeUsdGeometry(UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeMeshData& meshData, bool uniformPrim);
UsdPrim InitializeUsdGeometry(UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeInstancerData& instancerData, bool uniformPrim);
UsdPrim InitializeUsdGeometry(UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeCurveData& curveData, bool uniformPrim);
UsdPrim InitializeUsdVolume(UsdStageRefPtr volumeStage, const SdfPath& volumePath, bool uniformPrim) const;
UsdShadeMaterial InitializeUsdMaterial(UsdStageRefPtr materialStage, const SdfPath& matPrimPath, bool uniformPrim) const;
void InitializeUsdSampler(UsdStageRefPtr samplerStage,const SdfPath& samplerPrimPath, UsdBridgeSamplerData::SamplerType type, bool uniformPrim) const;
void InitializeUsdCamera(UsdStageRefPtr cameraStage, const SdfPath& geomPath);
UsdShadeShader GetOrCreateAttributeReader() const;
#ifdef USE_INDEX_MATERIALS
UsdShadeMaterial InitializeIndexVolumeMaterial_Impl(UsdStageRefPtr volumeStage,
const SdfPath& volumePath, bool uniformPrim, const UsdBridgeTimeEvaluator<UsdBridgeVolumeData>* timeEval = nullptr) const;
#endif
#ifdef VALUE_CLIP_RETIMING
void UpdateUsdGeometryManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeMeshData& meshData);
void UpdateUsdGeometryManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeInstancerData& instancerData);
void UpdateUsdGeometryManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeCurveData& curveData);
void UpdateUsdVolumeManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeVolumeData& volumeData);
void UpdateUsdMaterialManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeMaterialData& matData);
void UpdateUsdSamplerManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeSamplerData& samplerData);
#endif
void BindMaterialToGeom(const SdfPath& refGeomPath, const SdfPath& refMatPath);
void ConnectSamplersToMaterial(UsdStageRefPtr materialStage, const SdfPath& matPrimPath, const SdfPrimPathList& refSamplerPrimPaths,
const UsdBridgePrimCacheList& samplerCacheEntries, const UsdSamplerRefData* samplerRefDatas, size_t numSamplers, double worldTimeStep); // Disconnect happens automatically at parameter overwrite
void UnbindMaterialFromGeom(const SdfPath & refGeomPath);
void UpdateUsdTransform(const SdfPath& transPrimPath, const float* transform, bool timeVarying, double timeStep);
void UpdateUsdGeometry(const UsdStagePtr& timeVarStage, const SdfPath& meshPath, const UsdBridgeMeshData& geomData, double timeStep);
void UpdateUsdGeometry(const UsdStagePtr& timeVarStage, const SdfPath& instancerPath, const UsdBridgeInstancerData& geomData, double timeStep);
void UpdateUsdGeometry(const UsdStagePtr& timeVarStage, const SdfPath& curvePath, const UsdBridgeCurveData& geomData, double timeStep);
void UpdateUsdMaterial(UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, const UsdBridgeMaterialData& matData, const UsdGeomPrimvarsAPI& boundGeomPrimvars, double timeStep);
void UpdatePsShader(UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, const UsdBridgeMaterialData& matData, const UsdGeomPrimvarsAPI& boundGeomPrimvars, double timeStep);
void UpdateMdlShader(UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, const UsdBridgeMaterialData& matData, const UsdGeomPrimvarsAPI& boundGeomPrimvars, double timeStep);
void UpdateUsdVolume(UsdStageRefPtr timeVarStage, UsdBridgePrimCache* cacheEntry, const UsdBridgeVolumeData& volumeData, double timeStep);
void UpdateUsdSampler(UsdStageRefPtr timeVarStage, UsdBridgePrimCache* cacheEntry, const UsdBridgeSamplerData& samplerData, double timeStep);
void UpdateUsdCamera(UsdStageRefPtr timeVarStage, const SdfPath& cameraPrimPath,
const UsdBridgeCameraData& cameraData, double timeStep, bool timeVarHasChanged);
void UpdateUsdInstancerPrototypes(const SdfPath& instancerPath, const UsdBridgeInstancerRefData& geomRefData, const SdfPrimPathList& refProtoGeomPrimPaths, const char* protoShapePathRp);
void UpdateAttributeReader(UsdStageRefPtr timeVarStage, const SdfPath& matPrimPath, MaterialDMI dataMemberId, const char* newName, const UsdGeomPrimvarsAPI& boundGeomPrimvars, double timeStep, MaterialDMI timeVarying);
void UpdateInAttribute(UsdStageRefPtr timeVarStage, const SdfPath& samplerPrimPath, const char* newName, double timeStep, SamplerDMI timeVarying);
void UpdateBeginEndTime(double timeStep);
#ifdef USE_INDEX_MATERIALS
void UpdateIndexVolumeMaterial(UsdStageRefPtr sceneStage, UsdStageRefPtr timeVarStage, const SdfPath& volumePath, const UsdBridgeVolumeData& volumeData, double timeStep);
#endif
void ResetSharedResourceModified();
TfToken& AttributeNameToken(const char* attribName);
friend void ResourceCollectVolume(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter);
friend void ResourceCollectSampler(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter);
friend void RemoveResourceFiles(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter,
const char* resourceFolder, const char* extension);
// Settings
UsdBridgeSettings Settings;
UsdBridgeConnectionSettings ConnectionSettings;
UsdBridgeLogObject LogObject;
protected:
// Connect
std::unique_ptr<UsdBridgeConnection> Connect = nullptr;
// Volume writer
std::shared_ptr<UsdBridgeVolumeWriterI> VolumeWriter; // shared - requires custom deleter
// Shared resource cache (ie. resources shared between UsdBridgePrimCache entries)
// Maps keys to a refcount and modified flag
using SharedResourceValue = std::pair<int, bool>;
using SharedResourceKV = std::pair<UsdBridgeResourceKey, SharedResourceValue>;
using SharedResourceContainer = std::vector<SharedResourceKV>;
SharedResourceContainer SharedResourceCache;
void AddSharedResourceRef(const UsdBridgeResourceKey& key);
bool RemoveSharedResourceRef(const UsdBridgeResourceKey& key);
// Sets modified flag and returns whether the shared resource has been modified since ResetSharedResourceModified()
bool SetSharedResourceModified(const UsdBridgeResourceKey& key);
// Token cache for attribute names
std::vector<TfToken> AttributeTokens;
// Session specific info
int SessionNumber = -1;
UsdStageRefPtr SceneStage;
UsdStageRefPtr ExternalSceneStage;
bool EnableSaving = true;
std::string SceneFileName;
std::string SessionDirectory;
std::string RootName;
std::string RootClassName;
#ifdef CUSTOM_PBR_MDL
SdfAssetPath MdlOpaqueRelFilePath; // relative from Scene Folder
SdfAssetPath MdlTranslucentRelFilePath; // relative from Scene Folder
#endif
double StartTime = 0.0;
double EndTime = 0.0;
std::string TempNameStr;
std::vector<unsigned char> TempImageData;
};
void RemoveResourceFiles(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter,
const char* resourceFolder, const char* fileExtension);
void ResourceCollectVolume(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter);
void ResourceCollectSampler(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter);
#endif | 13,391 | C | 59.597285 | 237 | 0.821074 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeUsdWriter_Volume.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeUsdWriter.h"
#include "UsdBridgeUsdWriter_Common.h"
namespace
{
void InitializeUsdVolumeTimeVar(UsdVolVolume& volume, const TimeEvaluator<UsdBridgeVolumeData>* timeEval = nullptr)
{
typedef UsdBridgeVolumeData::DataMemberId DMI;
}
void InitializeUsdVolumeAssetTimeVar(UsdVolOpenVDBAsset& volAsset, const TimeEvaluator<UsdBridgeVolumeData>* timeEval = nullptr)
{
typedef UsdBridgeVolumeData::DataMemberId DMI;
UsdVolOpenVDBAsset& attribCreatePrim = volAsset;
UsdPrim attribRemovePrim = volAsset.GetPrim();
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::DATA, CreateFilePathAttr, UsdBridgeTokens->filePath);
}
UsdPrim InitializeUsdVolume_Impl(UsdStageRefPtr volumeStage, const SdfPath & volumePath, bool uniformPrim,
TimeEvaluator<UsdBridgeVolumeData>* timeEval = nullptr)
{
UsdVolVolume volume = GetOrDefinePrim<UsdVolVolume>(volumeStage, volumePath);
SdfPath ovdbFieldPath = volumePath.AppendPath(SdfPath(constring::openVDBPrimPf));
UsdVolOpenVDBAsset volAsset = GetOrDefinePrim<UsdVolOpenVDBAsset>(volumeStage, ovdbFieldPath);
if (uniformPrim)
{
volume.CreateFieldRelationship(UsdBridgeTokens->density, ovdbFieldPath);
volAsset.CreateFieldNameAttr(VtValue(UsdBridgeTokens->density));
}
InitializeUsdVolumeTimeVar(volume, timeEval);
InitializeUsdVolumeAssetTimeVar(volAsset, timeEval);
return volume.GetPrim();
}
void UpdateUsdVolumeAttributes(UsdVolVolume& uniformVolume, UsdVolVolume& timeVarVolume, UsdVolOpenVDBAsset& uniformField, UsdVolOpenVDBAsset& timeVarField,
const UsdBridgeVolumeData& volumeData, double timeStep, const std::string& relVolPath)
{
TimeEvaluator<UsdBridgeVolumeData> timeEval(volumeData, timeStep);
typedef UsdBridgeVolumeData::DataMemberId DMI;
SdfAssetPath volAsset(relVolPath);
// Set extents in usd
float minX = volumeData.Origin[0];
float minY = volumeData.Origin[1];
float minZ = volumeData.Origin[2];
float maxX = ((float)volumeData.NumElements[0] * volumeData.CellDimensions[0]) + minX;
float maxY = ((float)volumeData.NumElements[1] * volumeData.CellDimensions[1]) + minY;
float maxZ = ((float)volumeData.NumElements[2] * volumeData.CellDimensions[2]) + minZ;
VtVec3fArray extentArray(2);
extentArray[0].Set(minX, minY, minZ);
extentArray[1].Set(maxX, maxY, maxZ);
UsdAttribute uniformFileAttr = uniformField.GetFilePathAttr();
UsdAttribute timeVarFileAttr = timeVarField.GetFilePathAttr();
UsdAttribute uniformExtentAttr = uniformVolume.GetExtentAttr();
UsdAttribute timeVarExtentAttr = timeVarVolume.GetExtentAttr();
bool dataTimeVarying = timeEval.IsTimeVarying(DMI::DATA);
// Clear timevarying attributes if necessary
ClearUsdAttributes(uniformFileAttr, timeVarFileAttr, dataTimeVarying);
ClearUsdAttributes(uniformExtentAttr, timeVarExtentAttr, dataTimeVarying);
// Set the attributes
SET_TIMEVARYING_ATTRIB(dataTimeVarying, timeVarFileAttr, uniformFileAttr, volAsset);
SET_TIMEVARYING_ATTRIB(dataTimeVarying, timeVarExtentAttr, uniformExtentAttr, extentArray);
}
}
UsdPrim UsdBridgeUsdWriter::InitializeUsdVolume(UsdStageRefPtr volumeStage, const SdfPath & volumePath, bool uniformPrim) const
{
UsdPrim volumePrim = InitializeUsdVolume_Impl(volumeStage, volumePath, uniformPrim);
#ifdef USE_INDEX_MATERIALS
UsdShadeMaterial matPrim = InitializeIndexVolumeMaterial_Impl(volumeStage, volumePath, uniformPrim);
UsdShadeMaterialBindingAPI(volumePrim).Bind(matPrim);
#endif
return volumePrim;
}
#ifdef VALUE_CLIP_RETIMING
void UsdBridgeUsdWriter::UpdateUsdVolumeManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeVolumeData& volumeData)
{
const SdfPath & volumePath = cacheEntry->PrimPath;
UsdStageRefPtr volumeStage = cacheEntry->ManifestStage.second;
TimeEvaluator<UsdBridgeVolumeData> timeEval(volumeData);
InitializeUsdVolume_Impl(volumeStage, volumePath,
false, &timeEval);
#ifdef USE_INDEX_MATERIALS
InitializeIndexVolumeMaterial_Impl(volumeStage, volumePath, false, &timeEval);
#endif
if(this->EnableSaving)
cacheEntry->ManifestStage.second->Save();
}
#endif
void UsdBridgeUsdWriter::UpdateUsdVolume(UsdStageRefPtr timeVarStage, UsdBridgePrimCache* cacheEntry, const UsdBridgeVolumeData& volumeData, double timeStep)
{
const SdfPath& volPrimPath = cacheEntry->PrimPath;
// Get the volume and ovdb field prims
UsdVolVolume uniformVolume = UsdVolVolume::Get(SceneStage, volPrimPath);
assert(uniformVolume);
UsdVolVolume timeVarVolume = UsdVolVolume::Get(timeVarStage, volPrimPath);
assert(timeVarVolume);
SdfPath ovdbFieldPath = volPrimPath.AppendPath(SdfPath(constring::openVDBPrimPf));
UsdVolOpenVDBAsset uniformField = UsdVolOpenVDBAsset::Get(SceneStage, ovdbFieldPath);
assert(uniformField);
UsdVolOpenVDBAsset timeVarField = UsdVolOpenVDBAsset::Get(timeVarStage, ovdbFieldPath);
assert(timeVarField);
// Set the file path reference in usd
const std::string& relVolPath = GetResourceFileName(constring::volFolder, cacheEntry->Name.GetString(), timeStep, constring::vdbExtension);
UpdateUsdVolumeAttributes(uniformVolume, timeVarVolume, uniformField, timeVarField, volumeData, timeStep, relVolPath);
#ifdef USE_INDEX_MATERIALS
UpdateIndexVolumeMaterial(SceneStage, timeVarStage, volPrimPath, volumeData, timeStep);
#endif
// Output stream path (relative from connection working dir)
std::string wdRelVolPath(SessionDirectory + relVolPath);
// Write VDB data to stream
VolumeWriter->ToVDB(volumeData);
// Flush stream out to storage
const char* volumeStreamData; size_t volumeStreamDataSize;
VolumeWriter->GetSerializedVolumeData(volumeStreamData, volumeStreamDataSize);
Connect->WriteFile(volumeStreamData, volumeStreamDataSize, wdRelVolPath.c_str(), true);
// Record file write for timestep
cacheEntry->AddResourceKey(UsdBridgeResourceKey(nullptr, timeStep));
}
void ResourceCollectVolume(UsdBridgePrimCache* cache, UsdBridgeUsdWriter& usdWriter)
{
RemoveResourceFiles(cache, usdWriter, constring::volFolder, constring::vdbExtension);
} | 6,214 | C++ | 38.335443 | 158 | 0.78822 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeTimeEvaluator.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeTimeEvaluator.h"
#include "usd.h"
PXR_NAMESPACE_USING_DIRECTIVE
const UsdTimeCode UsdBridgeTimeEvaluator<bool>::DefaultTime = UsdTimeCode::Default(); | 245 | C++ | 29.749996 | 85 | 0.795918 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeUsdWriter_Geometry.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeUsdWriter.h"
#include "UsdBridgeUsdWriter_Common.h"
namespace
{
template<typename UsdGeomType>
UsdAttribute UsdGeomGetPointsAttribute(UsdGeomType& usdGeom) { return UsdAttribute(); }
template<>
UsdAttribute UsdGeomGetPointsAttribute(UsdGeomMesh& usdGeom) { return usdGeom.GetPointsAttr(); }
template<>
UsdAttribute UsdGeomGetPointsAttribute(UsdGeomPoints& usdGeom) { return usdGeom.GetPointsAttr(); }
template<>
UsdAttribute UsdGeomGetPointsAttribute(UsdGeomBasisCurves& usdGeom) { return usdGeom.GetPointsAttr(); }
template<>
UsdAttribute UsdGeomGetPointsAttribute(UsdGeomPointInstancer& usdGeom) { return usdGeom.GetPositionsAttr(); }
template<typename GeomDataType>
void CreateUsdGeomColorPrimvars(UsdGeomPrimvarsAPI& primvarApi, const GeomDataType& geomData, const UsdBridgeSettings& settings, const TimeEvaluator<GeomDataType>* timeEval = nullptr)
{
using DMI = typename GeomDataType::DataMemberId;
bool timeVarChecked = true;
if(timeEval)
{
timeVarChecked = timeEval->IsTimeVarying(DMI::COLORS);
}
if (timeVarChecked)
{
primvarApi.CreatePrimvar(UsdBridgeTokens->color, SdfValueTypeNames->Float4Array);
}
else
{
primvarApi.RemovePrimvar(UsdBridgeTokens->color);
}
}
template<typename GeomDataType>
void CreateUsdGeomTexturePrimvars(UsdGeomPrimvarsAPI& primvarApi, const GeomDataType& geomData, const UsdBridgeSettings& settings, const TimeEvaluator<GeomDataType>* timeEval = nullptr)
{
using DMI = typename GeomDataType::DataMemberId;
bool timeVarChecked = true;
if(timeEval)
{
timeVarChecked = timeEval->IsTimeVarying(DMI::ATTRIBUTE0);
}
if (timeVarChecked)
primvarApi.CreatePrimvar(UsdBridgeTokens->st, SdfValueTypeNames->TexCoord2fArray);
else if (timeEval)
primvarApi.RemovePrimvar(UsdBridgeTokens->st);
}
template<typename GeomDataType>
void CreateUsdGeomAttributePrimvar(UsdBridgeUsdWriter* writer, UsdGeomPrimvarsAPI& primvarApi, const GeomDataType& geomData, uint32_t attribIndex, const TimeEvaluator<GeomDataType>* timeEval = nullptr)
{
using DMI = typename GeomDataType::DataMemberId;
const UsdBridgeAttribute& attrib = geomData.Attributes[attribIndex];
if(attrib.DataType != UsdBridgeType::UNDEFINED)
{
bool timeVarChecked = true;
if(timeEval)
{
DMI attributeId = DMI::ATTRIBUTE0 + attribIndex;
timeVarChecked = timeEval->IsTimeVarying(attributeId);
}
TfToken attribToken = attrib.Name ? writer->AttributeNameToken(attrib.Name) : AttribIndexToToken(attribIndex);
if(timeVarChecked)
{
SdfValueTypeName primvarType = GetPrimvarArrayType(attrib.DataType);
if(primvarType == SdfValueTypeNames->BoolArray)
{
UsdBridgeLogMacro(writer->LogObject, UsdBridgeLogLevel::WARNING, "UsdGeom Attribute<" << attribIndex << "> primvar does not support source data type: " << attrib.DataType);
}
// Allow for attrib primvar types to change
UsdGeomPrimvar primvar = primvarApi.GetPrimvar(attribToken);
if(primvar && primvar.GetTypeName() != primvarType)
{
primvarApi.RemovePrimvar(attribToken);
}
primvarApi.CreatePrimvar(attribToken, primvarType);
}
else if(timeEval)
{
primvarApi.RemovePrimvar(attribToken);
}
}
}
template<typename GeomDataType>
void CreateUsdGeomAttributePrimvars(UsdBridgeUsdWriter* writer, UsdGeomPrimvarsAPI& primvarApi, const GeomDataType& geomData, const TimeEvaluator<GeomDataType>* timeEval = nullptr)
{
for(uint32_t attribIndex = 0; attribIndex < geomData.NumAttributes; ++attribIndex)
{
CreateUsdGeomAttributePrimvar(writer, primvarApi, geomData, attribIndex, timeEval);
}
}
void InitializeUsdGeometryTimeVar(UsdBridgeUsdWriter* writer, UsdGeomMesh& meshGeom, const UsdBridgeMeshData& meshData, const UsdBridgeSettings& settings,
const TimeEvaluator<UsdBridgeMeshData>* timeEval = nullptr)
{
typedef UsdBridgeMeshData::DataMemberId DMI;
UsdGeomPrimvarsAPI primvarApi(meshGeom);
UsdGeomMesh& attribCreatePrim = meshGeom;
UsdPrim attribRemovePrim = meshGeom.GetPrim();
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::POINTS, CreatePointsAttr, UsdBridgeTokens->points);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::POINTS, CreateExtentAttr, UsdBridgeTokens->extent);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::INDICES, CreateFaceVertexIndicesAttr, UsdBridgeTokens->faceVertexCounts);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::INDICES, CreateFaceVertexCountsAttr, UsdBridgeTokens->faceVertexIndices);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::NORMALS, CreateNormalsAttr, UsdBridgeTokens->normals);
CreateUsdGeomColorPrimvars(primvarApi, meshData, settings, timeEval);
if(settings.EnableStTexCoords)
CreateUsdGeomTexturePrimvars(primvarApi, meshData, settings, timeEval);
CreateUsdGeomAttributePrimvars(writer, primvarApi, meshData, timeEval);
}
void InitializeUsdGeometryTimeVar(UsdBridgeUsdWriter* writer, UsdGeomPoints& pointsGeom, const UsdBridgeInstancerData& instancerData, const UsdBridgeSettings& settings,
const TimeEvaluator<UsdBridgeInstancerData>* timeEval = nullptr)
{
typedef UsdBridgeInstancerData::DataMemberId DMI;
UsdGeomPrimvarsAPI primvarApi(pointsGeom);
UsdGeomPoints& attribCreatePrim = pointsGeom;
UsdPrim attribRemovePrim = pointsGeom.GetPrim();
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::POINTS, CreatePointsAttr, UsdBridgeTokens->points);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::POINTS, CreateExtentAttr, UsdBridgeTokens->extent);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::INSTANCEIDS, CreateIdsAttr, UsdBridgeTokens->ids);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::ORIENTATIONS, CreateNormalsAttr, UsdBridgeTokens->normals);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::SCALES, CreateWidthsAttr, UsdBridgeTokens->widths);
CreateUsdGeomColorPrimvars(primvarApi, instancerData, settings, timeEval);
if(settings.EnableStTexCoords)
CreateUsdGeomTexturePrimvars(primvarApi, instancerData, settings, timeEval);
CreateUsdGeomAttributePrimvars(writer, primvarApi, instancerData, timeEval);
}
void InitializeUsdGeometryTimeVar(UsdBridgeUsdWriter* writer, UsdGeomPointInstancer& pointsGeom, const UsdBridgeInstancerData& instancerData, const UsdBridgeSettings& settings,
const TimeEvaluator<UsdBridgeInstancerData>* timeEval = nullptr)
{
typedef UsdBridgeInstancerData::DataMemberId DMI;
UsdGeomPrimvarsAPI primvarApi(pointsGeom);
UsdGeomPointInstancer& attribCreatePrim = pointsGeom;
UsdPrim attribRemovePrim = pointsGeom.GetPrim();
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::POINTS, CreatePositionsAttr, UsdBridgeTokens->positions);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::POINTS, CreateExtentAttr, UsdBridgeTokens->extent);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::SHAPEINDICES, CreateProtoIndicesAttr, UsdBridgeTokens->protoIndices);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::INSTANCEIDS, CreateIdsAttr, UsdBridgeTokens->ids);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::ORIENTATIONS, CreateOrientationsAttr, UsdBridgeTokens->orientations);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::SCALES, CreateScalesAttr, UsdBridgeTokens->scales);
CreateUsdGeomColorPrimvars(primvarApi, instancerData, settings, timeEval);
if(settings.EnableStTexCoords)
CreateUsdGeomTexturePrimvars(primvarApi, instancerData, settings, timeEval);
CreateUsdGeomAttributePrimvars(writer, primvarApi, instancerData, timeEval);
//CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::LINEARVELOCITIES, CreateVelocitiesAttr, UsdBridgeTokens->velocities);
//CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::ANGULARVELOCITIES, CreateAngularVelocitiesAttr, UsdBridgeTokens->angularVelocities);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::INVISIBLEIDS, CreateInvisibleIdsAttr, UsdBridgeTokens->invisibleIds);
}
void InitializeUsdGeometryTimeVar(UsdBridgeUsdWriter* writer, UsdGeomBasisCurves& curveGeom, const UsdBridgeCurveData& curveData, const UsdBridgeSettings& settings,
const TimeEvaluator<UsdBridgeCurveData>* timeEval = nullptr)
{
typedef UsdBridgeCurveData::DataMemberId DMI;
UsdGeomPrimvarsAPI primvarApi(curveGeom);
UsdGeomBasisCurves& attribCreatePrim = curveGeom;
UsdPrim attribRemovePrim = curveGeom.GetPrim();
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::POINTS, CreatePointsAttr, UsdBridgeTokens->positions);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::POINTS, CreateExtentAttr, UsdBridgeTokens->extent);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::CURVELENGTHS, CreateCurveVertexCountsAttr, UsdBridgeTokens->curveVertexCounts);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::NORMALS, CreateNormalsAttr, UsdBridgeTokens->normals);
CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(DMI::SCALES, CreateWidthsAttr, UsdBridgeTokens->widths);
CreateUsdGeomColorPrimvars(primvarApi, curveData, settings, timeEval);
if(settings.EnableStTexCoords)
CreateUsdGeomTexturePrimvars(primvarApi, curveData, settings, timeEval);
CreateUsdGeomAttributePrimvars(writer, primvarApi, curveData, timeEval);
}
UsdPrim InitializeUsdGeometry_Impl(UsdBridgeUsdWriter* writer, UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeMeshData& meshData, bool uniformPrim,
const UsdBridgeSettings& settings,
TimeEvaluator<UsdBridgeMeshData>* timeEval = nullptr)
{
UsdGeomMesh geomMesh = GetOrDefinePrim<UsdGeomMesh>(geometryStage, geomPath);
InitializeUsdGeometryTimeVar(writer, geomMesh, meshData, settings, timeEval);
if (uniformPrim)
{
geomMesh.CreateDoubleSidedAttr(VtValue(true));
geomMesh.CreateSubdivisionSchemeAttr().Set(UsdGeomTokens->none);
}
return geomMesh.GetPrim();
}
UsdPrim InitializeUsdGeometry_Impl(UsdBridgeUsdWriter* writer, UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeInstancerData& instancerData, bool uniformPrim,
const UsdBridgeSettings& settings,
TimeEvaluator<UsdBridgeInstancerData>* timeEval = nullptr)
{
if (instancerData.UseUsdGeomPoints)
{
UsdGeomPoints geomPoints = GetOrDefinePrim<UsdGeomPoints>(geometryStage, geomPath);
InitializeUsdGeometryTimeVar(writer, geomPoints, instancerData, settings, timeEval);
if (uniformPrim)
{
geomPoints.CreateDoubleSidedAttr(VtValue(true));
}
return geomPoints.GetPrim();
}
else
{
UsdGeomPointInstancer geomPoints = GetOrDefinePrim<UsdGeomPointInstancer>(geometryStage, geomPath);
InitializeUsdGeometryTimeVar(writer, geomPoints, instancerData, settings, timeEval);
return geomPoints.GetPrim();
}
}
UsdPrim InitializeUsdGeometry_Impl(UsdBridgeUsdWriter* writer, UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeCurveData& curveData, bool uniformPrim,
const UsdBridgeSettings& settings,
TimeEvaluator<UsdBridgeCurveData>* timeEval = nullptr)
{
UsdGeomBasisCurves geomCurves = GetOrDefinePrim<UsdGeomBasisCurves>(geometryStage, geomPath);
InitializeUsdGeometryTimeVar(writer, geomCurves, curveData, settings, timeEval);
if (uniformPrim)
{
geomCurves.CreateDoubleSidedAttr(VtValue(true));
geomCurves.GetTypeAttr().Set(UsdGeomTokens->linear);
}
return geomCurves.GetPrim();
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomPoints(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::POINTS);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::POINTS);
ClearUsdAttributes(UsdGeomGetPointsAttribute(uniformGeom), UsdGeomGetPointsAttribute(timeVarGeom), timeVaryingUpdate);
ClearUsdAttributes(uniformGeom.GetExtentAttr(), timeVarGeom.GetExtentAttr(), timeVaryingUpdate);
if (performsUpdate)
{
if (!geomData.Points)
{
UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "GeomData requires points.");
}
else
{
UsdGeomType* outGeom = timeVaryingUpdate ? &timeVarGeom : &uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::POINTS);
// Points
UsdAttribute pointsAttr = UsdGeomGetPointsAttribute(*outGeom);
const void* arrayData = geomData.Points;
size_t arrayNumElements = geomData.NumPoints;
UsdAttribute arrayPrimvar = pointsAttr;
VtVec3fArray& usdVerts = GetStaticTempArray<VtVec3fArray>();
bool setPrimvar = true;
switch (geomData.PointsType)
{
case UsdBridgeType::FLOAT3: {ASSIGN_PRIMVAR_CUSTOM_ARRAY_MACRO(VtVec3fArray, usdVerts); break; }
case UsdBridgeType::DOUBLE3: {ASSIGN_PRIMVAR_CONVERT_CUSTOM_ARRAY_MACRO(VtVec3fArray, GfVec3d, usdVerts); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom PointsAttr should be FLOAT3 or DOUBLE3."); break; }
}
// Usd requires extent.
GfRange3f extent;
for (const auto& pt : usdVerts) {
extent.UnionWith(pt);
}
VtVec3fArray extentArray(2);
extentArray[0] = extent.GetMin();
extentArray[1] = extent.GetMax();
outGeom->GetExtentAttr().Set(extentArray, timeCode);
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomIndices(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::INDICES);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::INDICES);
ClearUsdAttributes(uniformGeom.GetFaceVertexIndicesAttr(), timeVarGeom.GetFaceVertexIndicesAttr(), timeVaryingUpdate);
ClearUsdAttributes(uniformGeom.GetFaceVertexCountsAttr(), timeVarGeom.GetFaceVertexCountsAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType* outGeom = timeVaryingUpdate ? &timeVarGeom : &uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::INDICES);
uint64_t numIndices = geomData.NumIndices;
VtArray<int>& usdVertexCounts = GetStaticTempArray<VtIntArray>();
usdVertexCounts.resize(numPrims);
int vertexCount = numIndices / numPrims;
for (uint64_t i = 0; i < numPrims; ++i)
usdVertexCounts[i] = vertexCount;//geomData.FaceVertCounts[i];
// Face Vertex counts
UsdAttribute faceVertCountsAttr = outGeom->GetFaceVertexCountsAttr();
faceVertCountsAttr.Set(usdVertexCounts, timeCode);
if (!geomData.Indices)
{
VtIntArray& tempIndices = GetStaticTempArray<VtIntArray>();
tempIndices.resize(numIndices);
for (uint64_t i = 0; i < numIndices; ++i)
tempIndices[i] = (int)i;
UsdAttribute arrayPrimvar = outGeom->GetFaceVertexIndicesAttr();
arrayPrimvar.Set(tempIndices, timeCode);
}
else
{
// Face indices
const void* arrayData = geomData.Indices;
size_t arrayNumElements = numIndices;
UsdAttribute arrayPrimvar = outGeom->GetFaceVertexIndicesAttr();
bool setPrimvar = true;
switch (geomData.IndicesType)
{
case UsdBridgeType::ULONG: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtIntArray, uint64_t); break; }
case UsdBridgeType::LONG: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtIntArray, int64_t); break; }
case UsdBridgeType::INT: {ASSIGN_PRIMVAR_MACRO(VtIntArray); break; }
case UsdBridgeType::UINT: {ASSIGN_PRIMVAR_MACRO(VtIntArray); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom FaceVertexIndicesAttr should be (U)LONG or (U)INT."); break; }
}
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomNormals(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::NORMALS);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::NORMALS);
ClearUsdAttributes(uniformGeom.GetNormalsAttr(), timeVarGeom.GetNormalsAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType* outGeom = timeVaryingUpdate ? &timeVarGeom : &uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::NORMALS);
UsdAttribute normalsAttr = outGeom->GetNormalsAttr();
if (geomData.Normals != nullptr)
{
const void* arrayData = geomData.Normals;
size_t arrayNumElements = geomData.PerPrimNormals ? numPrims : geomData.NumPoints;
UsdAttribute arrayPrimvar = normalsAttr;
bool setPrimvar = true;
switch (geomData.NormalsType)
{
case UsdBridgeType::FLOAT3: {ASSIGN_PRIMVAR_MACRO(VtVec3fArray); break; }
case UsdBridgeType::DOUBLE3: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtVec3fArray, GfVec3d); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom NormalsAttr should be FLOAT3 or DOUBLE3."); break; }
}
// Per face or per-vertex interpolation. This will break timesteps that have been written before.
TfToken normalInterpolation = geomData.PerPrimNormals ? UsdGeomTokens->uniform : UsdGeomTokens->vertex;
uniformGeom.SetNormalsInterpolation(normalInterpolation);
}
else
{
normalsAttr.Set(SdfValueBlock(), timeCode);
}
}
}
template<typename GeomDataType>
void UpdateUsdGeomTexCoords(UsdBridgeUsdWriter* writer, UsdGeomPrimvarsAPI& timeVarPrimvars, UsdGeomPrimvarsAPI& uniformPrimvars, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::ATTRIBUTE0);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::ATTRIBUTE0);
UsdGeomPrimvar uniformPrimvar = uniformPrimvars.GetPrimvar(UsdBridgeTokens->st);
UsdGeomPrimvar timeVarPrimvar = timeVarPrimvars.GetPrimvar(UsdBridgeTokens->st);
ClearUsdAttributes(uniformPrimvar.GetAttr(), timeVarPrimvar.GetAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdTimeCode timeCode = timeEval.Eval(DMI::ATTRIBUTE0);
UsdAttribute texcoordPrimvar = timeVaryingUpdate ? timeVarPrimvar : uniformPrimvar;
assert(texcoordPrimvar);
const UsdBridgeAttribute& texCoordAttrib = geomData.Attributes[0];
if (texCoordAttrib.Data != nullptr)
{
const void* arrayData = texCoordAttrib.Data;
size_t arrayNumElements = texCoordAttrib.PerPrimData ? numPrims : geomData.NumPoints;
UsdAttribute arrayPrimvar = texcoordPrimvar;
bool setPrimvar = true;
switch (texCoordAttrib.DataType)
{
case UsdBridgeType::FLOAT2: { ASSIGN_PRIMVAR_MACRO(VtVec2fArray); break; }
case UsdBridgeType::DOUBLE2: { ASSIGN_PRIMVAR_CONVERT_MACRO(VtVec2fArray, GfVec2d); break; }
default: { UsdBridgeLogMacro(writer->LogObject, UsdBridgeLogLevel::ERR, "UsdGeom st primvar should be FLOAT2 or DOUBLE2."); break; }
}
// Per face or per-vertex interpolation. This will break timesteps that have been written before.
TfToken texcoordInterpolation = texCoordAttrib.PerPrimData ? UsdGeomTokens->uniform : UsdGeomTokens->vertex;
uniformPrimvar.SetInterpolation(texcoordInterpolation);
}
else
{
texcoordPrimvar.Set(SdfValueBlock(), timeCode);
}
}
}
template<typename GeomDataType>
void UpdateUsdGeomAttribute(UsdBridgeUsdWriter* writer, UsdGeomPrimvarsAPI& timeVarPrimvars, UsdGeomPrimvarsAPI& uniformPrimvars, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval, uint32_t attribIndex)
{
assert(attribIndex < geomData.NumAttributes);
const UsdBridgeAttribute& bridgeAttrib = geomData.Attributes[attribIndex];
TfToken attribToken = bridgeAttrib.Name ? writer->AttributeNameToken(bridgeAttrib.Name) : AttribIndexToToken(attribIndex);
UsdGeomPrimvar uniformPrimvar = uniformPrimvars.GetPrimvar(attribToken);
// The uniform primvar has to exist, otherwise any timevarying data will be ignored as well
if(!uniformPrimvar || uniformPrimvar.GetTypeName() != GetPrimvarArrayType(bridgeAttrib.DataType))
{
CreateUsdGeomAttributePrimvar(writer, uniformPrimvars, geomData, attribIndex); // No timeEval, to force attribute primvar creation on the uniform api
}
UsdGeomPrimvar timeVarPrimvar = timeVarPrimvars.GetPrimvar(attribToken);
if(!timeVarPrimvar || timeVarPrimvar.GetTypeName() != GetPrimvarArrayType(bridgeAttrib.DataType)) // even though new clipstages initialize the correct primvar type/name, it may still be wrong for existing ones (or primstages if so configured)
{
CreateUsdGeomAttributePrimvar(writer, timeVarPrimvars, geomData, attribIndex, &timeEval);
}
using DMI = typename GeomDataType::DataMemberId;
DMI attributeId = DMI::ATTRIBUTE0 + attribIndex;
bool performsUpdate = updateEval.PerformsUpdate(attributeId);
bool timeVaryingUpdate = timeEval.IsTimeVarying(attributeId);
ClearUsdAttributes(uniformPrimvar.GetAttr(), timeVarPrimvar.GetAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdTimeCode timeCode = timeEval.Eval(attributeId);
UsdAttribute attributePrimvar = timeVaryingUpdate ? timeVarPrimvar : uniformPrimvar;
if(!attributePrimvar)
{
UsdBridgeLogMacro(writer->LogObject, UsdBridgeLogLevel::ERR, "UsdGeom Attribute<Index> primvar not found, was the attribute at requested index valid during initialization of the prim? Index is " << attribIndex);
}
else
{
if (bridgeAttrib.Data != nullptr)
{
const void* arrayData = bridgeAttrib.Data;
size_t arrayNumElements = bridgeAttrib.PerPrimData ? numPrims : geomData.NumPoints;
UsdAttribute arrayPrimvar = attributePrimvar;
AssignAttribArrayToPrimvar(writer->LogObject, arrayData, bridgeAttrib.DataType, arrayNumElements, arrayPrimvar, timeCode);
// Per face or per-vertex interpolation. This will break timesteps that have been written before.
TfToken attribInterpolation = bridgeAttrib.PerPrimData ? UsdGeomTokens->uniform : UsdGeomTokens->vertex;
uniformPrimvar.SetInterpolation(attribInterpolation);
}
else
{
attributePrimvar.Set(SdfValueBlock(), timeCode);
}
}
}
}
template<typename GeomDataType>
void UpdateUsdGeomAttributes(UsdBridgeUsdWriter* writer, UsdGeomPrimvarsAPI& timeVarPrimvars, UsdGeomPrimvarsAPI& uniformPrimvars, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
uint32_t startIdx = 0;
for(uint32_t attribIndex = startIdx; attribIndex < geomData.NumAttributes; ++attribIndex)
{
const UsdBridgeAttribute& attrib = geomData.Attributes[attribIndex];
if(attrib.DataType != UsdBridgeType::UNDEFINED)
UpdateUsdGeomAttribute(writer, timeVarPrimvars, uniformPrimvars, geomData, numPrims, updateEval, timeEval, attribIndex);
}
}
template<typename GeomDataType>
void UpdateUsdGeomColors(UsdBridgeUsdWriter* writer, UsdGeomPrimvarsAPI& timeVarPrimvars, UsdGeomPrimvarsAPI& uniformPrimvars, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::COLORS);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::COLORS);
UsdGeomPrimvar uniformDispPrimvar = uniformPrimvars.GetPrimvar(UsdBridgeTokens->color);
UsdGeomPrimvar timeVarDispPrimvar = timeVarPrimvars.GetPrimvar(UsdBridgeTokens->color);
ClearUsdAttributes(uniformDispPrimvar.GetAttr(), timeVarDispPrimvar.GetAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdTimeCode timeCode = timeEval.Eval(DMI::COLORS);
UsdGeomPrimvar colorPrimvar = timeVaryingUpdate ? timeVarDispPrimvar : uniformDispPrimvar;
if (geomData.Colors != nullptr)
{
size_t arrayNumElements = geomData.PerPrimColors ? numPrims : geomData.NumPoints;
assert(colorPrimvar);
AssignColorArrayToPrimvar(writer->LogObject, geomData.Colors, arrayNumElements, geomData.ColorsType, timeEval.Eval(DMI::COLORS), colorPrimvar.GetAttr());
// Per face or per-vertex interpolation. This will break timesteps that have been written before.
TfToken colorInterpolation = geomData.PerPrimColors ? UsdGeomTokens->uniform : UsdGeomTokens->vertex;
uniformDispPrimvar.SetInterpolation(colorInterpolation);
}
else
{
colorPrimvar.GetAttr().Set(SdfValueBlock(), timeCode);
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomInstanceIds(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::INSTANCEIDS);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::INSTANCEIDS);
ClearUsdAttributes(uniformGeom.GetIdsAttr(), timeVarGeom.GetIdsAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType* outGeom = timeVaryingUpdate ? &timeVarGeom : &uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::INSTANCEIDS);
UsdAttribute idsAttr = outGeom->GetIdsAttr();
if (geomData.InstanceIds)
{
const void* arrayData = geomData.InstanceIds;
size_t arrayNumElements = geomData.NumPoints;
UsdAttribute arrayPrimvar = idsAttr;
bool setPrimvar = true;
switch (geomData.InstanceIdsType)
{
case UsdBridgeType::UINT: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtInt64Array, unsigned int); break; }
case UsdBridgeType::INT: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtInt64Array, int); break; }
case UsdBridgeType::LONG: {ASSIGN_PRIMVAR_MACRO(VtInt64Array); break; }
case UsdBridgeType::ULONG: {ASSIGN_PRIMVAR_MACRO(VtInt64Array); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom IdsAttribute should be (U)LONG or (U)INT."); break; }
}
}
else
{
idsAttr.Set(SdfValueBlock(), timeCode);
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomWidths(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::SCALES);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::SCALES);
ClearUsdAttributes(uniformGeom.GetWidthsAttr(), timeVarGeom.GetWidthsAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType& outGeom = timeVaryingUpdate ? timeVarGeom : uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::SCALES);
UsdAttribute widthsAttribute = outGeom.GetWidthsAttr();
assert(widthsAttribute);
if (geomData.Scales)
{
const void* arrayData = geomData.Scales;
size_t arrayNumElements = geomData.NumPoints;
UsdAttribute arrayPrimvar = widthsAttribute;
bool setPrimvar = false;
auto doubleFn = [](VtFloatArray& usdArray) { for(auto& x : usdArray) { x *= 2.0f; } };
switch (geomData.ScalesType)
{
case UsdBridgeType::FLOAT: {ASSIGN_PRIMVAR_MACRO(VtFloatArray); doubleFn(usdArray); arrayPrimvar.Set(usdArray, timeCode); break; }
case UsdBridgeType::DOUBLE: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtFloatArray, double); doubleFn(usdArray); arrayPrimvar.Set(usdArray, timeCode); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom WidthsAttribute should be FLOAT or DOUBLE."); break; }
}
}
else
{
// Remember that widths define a diameter, so a default width (1.0) corresponds to a scale of 0.5.
if(geomData.getUniformScale() != 0.5f)
{
VtFloatArray& usdWidths = GetStaticTempArray<VtFloatArray>();
usdWidths.resize(geomData.NumPoints);
for(auto& x : usdWidths) x = geomData.getUniformScale() * 2.0f;
widthsAttribute.Set(usdWidths, timeCode);
}
else
{
widthsAttribute.Set(SdfValueBlock(), timeCode);
}
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomScales(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::SCALES);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::SCALES);
ClearUsdAttributes(uniformGeom.GetScalesAttr(), timeVarGeom.GetScalesAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType& outGeom = timeVaryingUpdate ? timeVarGeom : uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::SCALES);
UsdAttribute scalesAttribute = outGeom.GetScalesAttr();
assert(scalesAttribute);
if (geomData.Scales)
{
const void* arrayData = geomData.Scales;
size_t arrayNumElements = geomData.NumPoints;
UsdAttribute arrayPrimvar = scalesAttribute;
bool setPrimvar = true;
switch (geomData.ScalesType)
{
case UsdBridgeType::FLOAT: {ASSIGN_PRIMVAR_MACRO_1EXPAND3(VtVec3fArray, float); break;}
case UsdBridgeType::DOUBLE: {ASSIGN_PRIMVAR_MACRO_1EXPAND3(VtVec3fArray, double); break;}
case UsdBridgeType::FLOAT3: {ASSIGN_PRIMVAR_MACRO(VtVec3fArray); break; }
case UsdBridgeType::DOUBLE3: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtVec3fArray, GfVec3d); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom ScalesAttribute should be FLOAT(3) or DOUBLE(3)."); break; }
}
}
else
{
if(!usdbridgenumerics::isIdentity(geomData.Scale))
{
GfVec3f defaultScale(geomData.Scale.Data);
VtVec3fArray& usdScales = GetStaticTempArray<VtVec3fArray>();
usdScales.resize(geomData.NumPoints);
for(auto& x : usdScales) x = defaultScale;
scalesAttribute.Set(usdScales, timeCode);
}
else
{
scalesAttribute.Set(SdfValueBlock(), timeCode);
}
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomOrientNormals(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::ORIENTATIONS);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::ORIENTATIONS);
ClearUsdAttributes(uniformGeom.GetNormalsAttr(), timeVarGeom.GetNormalsAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType& outGeom = timeVaryingUpdate ? timeVarGeom : uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::ORIENTATIONS);
UsdAttribute normalsAttribute = outGeom.GetNormalsAttr();
assert(normalsAttribute);
if (geomData.Orientations)
{
const void* arrayData = geomData.Orientations;
size_t arrayNumElements = geomData.NumPoints;
UsdAttribute arrayPrimvar = normalsAttribute;
bool setPrimvar = true;
switch (geomData.OrientationsType)
{
case UsdBridgeType::FLOAT3: {ASSIGN_PRIMVAR_MACRO(VtVec3fArray); break; }
case UsdBridgeType::DOUBLE3: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtVec3fArray, GfVec3d); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom NormalsAttribute (orientations) should be FLOAT3 or DOUBLE3."); break; }
}
}
else
{
//GfVec3f defaultNormal(1, 0, 0);
//VtVec3fArray& usdNormals = GetStaticTempArray<VtVec3fArray>();
//usdNormals.resize(geomData.NumPoints);
//for(auto& x : usdNormals) x = defaultNormal;
//normalsAttribute.Set(usdNormals, timeCode);
normalsAttribute.Set(SdfValueBlock(), timeCode);
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomOrientations(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::ORIENTATIONS);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::ORIENTATIONS);
ClearUsdAttributes(uniformGeom.GetOrientationsAttr(), timeVarGeom.GetOrientationsAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType& outGeom = timeVaryingUpdate ? timeVarGeom : uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::ORIENTATIONS);
// Orientations
UsdAttribute orientationsAttribute = outGeom.GetOrientationsAttr();
assert(orientationsAttribute);
VtQuathArray& usdOrients = GetStaticTempArray<VtQuathArray>();
if (geomData.Orientations)
{
usdOrients.resize(geomData.NumPoints);
switch (geomData.OrientationsType)
{
case UsdBridgeType::FLOAT3: { ConvertNormalsToQuaternions<float>(usdOrients, geomData.Orientations, geomData.NumPoints); break; }
case UsdBridgeType::DOUBLE3: { ConvertNormalsToQuaternions<double>(usdOrients, geomData.Orientations, geomData.NumPoints); break; }
case UsdBridgeType::FLOAT4:
{
for (uint64_t i = 0; i < geomData.NumPoints; ++i)
{
const float* orients = reinterpret_cast<const float*>(geomData.Orientations);
usdOrients[i] = GfQuath(orients[i * 4], orients[i * 4 + 1], orients[i * 4 + 2], orients[i * 4 + 3]);
}
orientationsAttribute.Set(usdOrients, timeCode);
break;
}
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom OrientationsAttribute should be FLOAT3, DOUBLE3 or FLOAT4."); break; }
}
orientationsAttribute.Set(usdOrients, timeCode);
}
else
{
if(!usdbridgenumerics::isIdentity(geomData.Orientation))
{
GfQuath defaultOrient(geomData.Orientation.Data[0], geomData.Orientation.Data[1], geomData.Orientation.Data[2], geomData.Orientation.Data[3]);
usdOrients.resize(geomData.NumPoints);
for(auto& x : usdOrients) x = defaultOrient;
orientationsAttribute.Set(usdOrients, timeCode);
}
else
{
orientationsAttribute.Set(SdfValueBlock(), timeCode);
}
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomProtoIndices(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::SHAPEINDICES);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::SHAPEINDICES);
if (performsUpdate)
{
UsdTimeCode timeCode = timeEval.Eval(DMI::SHAPEINDICES);
UsdGeomType* outGeom = timeCode.IsDefault() ? &uniformGeom : &timeVarGeom;
UsdAttribute protoIndexAttr = outGeom->GetProtoIndicesAttr();
assert(protoIndexAttr);
//Shape indices
if(geomData.ShapeIndices)
{
const void* arrayData = geomData.ShapeIndices;
size_t arrayNumElements = geomData.NumPoints;
UsdAttribute arrayPrimvar = protoIndexAttr;
bool setPrimvar = true;
switch (geomData.OrientationsType)
{
case UsdBridgeType::INT: {ASSIGN_PRIMVAR_MACRO(VtIntArray); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom ProtoIndicesAttr (ShapeIndices) should be INT."); break; }
}
}
else
{
VtIntArray& protoIndices = GetStaticTempArray<VtIntArray>();
protoIndices.resize(geomData.NumPoints);
for(auto& x : protoIndices) x = 0;
protoIndexAttr.Set(protoIndices, timeCode);
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomLinearVelocities(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::LINEARVELOCITIES);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::LINEARVELOCITIES);
ClearUsdAttributes(uniformGeom.GetVelocitiesAttr(), timeVarGeom.GetVelocitiesAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType& outGeom = timeVaryingUpdate ? timeVarGeom : uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::LINEARVELOCITIES);
// Linear velocities
UsdAttribute linearVelocitiesAttribute = outGeom.GetVelocitiesAttr();
assert(linearVelocitiesAttribute);
if (geomData.LinearVelocities)
{
GfVec3f* linVels = (GfVec3f*)geomData.LinearVelocities;
VtVec3fArray& usdVelocities = GetStaticTempArray<VtVec3fArray>();
usdVelocities.assign(linVels, linVels + geomData.NumPoints);
linearVelocitiesAttribute.Set(usdVelocities, timeCode);
}
else
{
linearVelocitiesAttribute.Set(SdfValueBlock(), timeCode);
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomAngularVelocities(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::ANGULARVELOCITIES);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::ANGULARVELOCITIES);
ClearUsdAttributes(uniformGeom.GetAngularVelocitiesAttr(), timeVarGeom.GetAngularVelocitiesAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType& outGeom = timeVaryingUpdate ? timeVarGeom : uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::ANGULARVELOCITIES);
// Angular velocities
UsdAttribute angularVelocitiesAttribute = outGeom.GetAngularVelocitiesAttr();
assert(angularVelocitiesAttribute);
if (geomData.AngularVelocities)
{
GfVec3f* angVels = (GfVec3f*)geomData.AngularVelocities;
VtVec3fArray& usdAngularVelocities = GetStaticTempArray<VtVec3fArray>();
usdAngularVelocities.assign(angVels, angVels + geomData.NumPoints);
angularVelocitiesAttribute.Set(usdAngularVelocities, timeCode);
}
else
{
angularVelocitiesAttribute.Set(SdfValueBlock(), timeCode);
}
}
}
template<typename UsdGeomType, typename GeomDataType>
void UpdateUsdGeomInvisibleIds(const UsdBridgeLogObject& logObj, UsdGeomType& timeVarGeom, UsdGeomType& uniformGeom, const GeomDataType& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const GeomDataType>& updateEval, TimeEvaluator<GeomDataType>& timeEval)
{
using DMI = typename GeomDataType::DataMemberId;
bool performsUpdate = updateEval.PerformsUpdate(DMI::INVISIBLEIDS);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::INVISIBLEIDS);
ClearUsdAttributes(uniformGeom.GetInvisibleIdsAttr(), timeVarGeom.GetInvisibleIdsAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomType& outGeom = timeVaryingUpdate ? timeVarGeom : uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::INVISIBLEIDS);
// Invisible ids
UsdAttribute invisIdsAttr = outGeom.GetInvisibleIdsAttr();
assert(invisIdsAttr);
uint64_t numInvisibleIds = geomData.NumInvisibleIds;
if (numInvisibleIds)
{
const void* arrayData = geomData.InvisibleIds;
size_t arrayNumElements = numInvisibleIds;
UsdAttribute arrayPrimvar = invisIdsAttr;
bool setPrimvar = true;
switch (geomData.InvisibleIdsType)
{
case UsdBridgeType::UINT: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtInt64Array, unsigned int); break; }
case UsdBridgeType::INT: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtInt64Array, int); break; }
case UsdBridgeType::LONG: {ASSIGN_PRIMVAR_MACRO(VtInt64Array); break; }
case UsdBridgeType::ULONG: {ASSIGN_PRIMVAR_MACRO(VtInt64Array); break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom GetInvisibleIdsAttr should be (U)LONG or (U)INT."); break; }
}
}
else
{
invisIdsAttr.Set(SdfValueBlock(), timeCode);
}
}
}
static void UpdateUsdGeomCurveLengths(const UsdBridgeLogObject& logObj, UsdGeomBasisCurves& timeVarGeom, UsdGeomBasisCurves& uniformGeom, const UsdBridgeCurveData& geomData, uint64_t numPrims,
UsdBridgeUpdateEvaluator<const UsdBridgeCurveData>& updateEval, TimeEvaluator<UsdBridgeCurveData>& timeEval)
{
using DMI = typename UsdBridgeCurveData::DataMemberId;
// Fill geom prim and geometry layer with data.
bool performsUpdate = updateEval.PerformsUpdate(DMI::CURVELENGTHS);
bool timeVaryingUpdate = timeEval.IsTimeVarying(DMI::CURVELENGTHS);
ClearUsdAttributes(uniformGeom.GetCurveVertexCountsAttr(), timeVarGeom.GetCurveVertexCountsAttr(), timeVaryingUpdate);
if (performsUpdate)
{
UsdGeomBasisCurves& outGeom = timeVaryingUpdate ? timeVarGeom : uniformGeom;
UsdTimeCode timeCode = timeEval.Eval(DMI::POINTS);
UsdAttribute vertCountAttr = outGeom.GetCurveVertexCountsAttr();
assert(vertCountAttr);
const void* arrayData = geomData.CurveLengths;
size_t arrayNumElements = geomData.NumCurveLengths;
UsdAttribute arrayPrimvar = vertCountAttr;
bool setPrimvar = true;
{ ASSIGN_PRIMVAR_MACRO(VtIntArray); }
}
}
void UpdateUsdGeomPrototypes(const UsdBridgeLogObject& logObj, const UsdStagePtr& sceneStage, UsdGeomPointInstancer& uniformGeom,
const UsdBridgeInstancerRefData& geomRefData, const SdfPrimPathList& protoGeomPaths,
const char* protoShapePathRp)
{
using DMI = typename UsdBridgeInstancerData::DataMemberId;
SdfPath protoBasePath = uniformGeom.GetPath().AppendPath(SdfPath(protoShapePathRp));
sceneStage->RemovePrim(protoBasePath);
UsdRelationship protoRel = uniformGeom.GetPrototypesRel();
for(int shapeIdx = 0; shapeIdx < geomRefData.NumShapes; ++shapeIdx)
{
SdfPath shapePath;
if(geomRefData.Shapes[shapeIdx] != UsdBridgeInstancerRefData::SHAPE_MESH)
{
std::string protoName = constring::protoShapePf + std::to_string(shapeIdx);
shapePath = protoBasePath.AppendPath(SdfPath(protoName.c_str()));
}
else
{
int protoGeomIdx = static_cast<int>(geomRefData.Shapes[shapeIdx]); // The mesh shape value is an index into protoGeomPaths
assert(protoGeomIdx < protoGeomPaths.size());
shapePath = protoGeomPaths[protoGeomIdx];
}
UsdGeomXformable geomXformable;
switch (geomRefData.Shapes[shapeIdx])
{
case UsdBridgeInstancerRefData::SHAPE_SPHERE:
{
geomXformable = UsdGeomSphere::Define(sceneStage, shapePath);
break;
}
case UsdBridgeInstancerRefData::SHAPE_CYLINDER:
{
geomXformable = UsdGeomCylinder::Define(sceneStage, shapePath);
break;
}
case UsdBridgeInstancerRefData::SHAPE_CONE:
{
geomXformable = UsdGeomCone::Define(sceneStage, shapePath);
break;
}
default:
{
geomXformable = UsdGeomXformable::Get(sceneStage, shapePath);
break;
}
}
// Add a transform
geomXformable.ClearXformOpOrder();
if(!usdbridgenumerics::isIdentity(geomRefData.ShapeTransform))
{
const float* transform = geomRefData.ShapeTransform.Data;
GfMatrix4d transMat;
transMat.SetRow(0, GfVec4d(GfVec4f(&transform[0])));
transMat.SetRow(1, GfVec4d(GfVec4f(&transform[4])));
transMat.SetRow(2, GfVec4d(GfVec4f(&transform[8])));
transMat.SetRow(3, GfVec4d(GfVec4f(&transform[12])));
geomXformable.AddTransformOp().Set(transMat);
}
protoRel.AddTarget(shapePath);
}
}
}
UsdPrim UsdBridgeUsdWriter::InitializeUsdGeometry(UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeMeshData& meshData, bool uniformPrim)
{
return InitializeUsdGeometry_Impl(this, geometryStage, geomPath, meshData, uniformPrim, Settings);
}
UsdPrim UsdBridgeUsdWriter::InitializeUsdGeometry(UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeInstancerData& instancerData, bool uniformPrim)
{
return InitializeUsdGeometry_Impl(this, geometryStage, geomPath, instancerData, uniformPrim, Settings);
}
UsdPrim UsdBridgeUsdWriter::InitializeUsdGeometry(UsdStageRefPtr geometryStage, const SdfPath& geomPath, const UsdBridgeCurveData& curveData, bool uniformPrim)
{
return InitializeUsdGeometry_Impl(this, geometryStage, geomPath, curveData, uniformPrim, Settings);
}
#ifdef VALUE_CLIP_RETIMING
void UsdBridgeUsdWriter::UpdateUsdGeometryManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeMeshData& meshData)
{
TimeEvaluator<UsdBridgeMeshData> timeEval(meshData);
InitializeUsdGeometry_Impl(this, cacheEntry->ManifestStage.second, cacheEntry->PrimPath, meshData, false,
Settings, &timeEval);
if(this->EnableSaving)
cacheEntry->ManifestStage.second->Save();
}
void UsdBridgeUsdWriter::UpdateUsdGeometryManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeInstancerData& instancerData)
{
TimeEvaluator<UsdBridgeInstancerData> timeEval(instancerData);
InitializeUsdGeometry_Impl(this, cacheEntry->ManifestStage.second, cacheEntry->PrimPath, instancerData, false,
Settings, &timeEval);
if(this->EnableSaving)
cacheEntry->ManifestStage.second->Save();
}
void UsdBridgeUsdWriter::UpdateUsdGeometryManifest(const UsdBridgePrimCache* cacheEntry, const UsdBridgeCurveData& curveData)
{
TimeEvaluator<UsdBridgeCurveData> timeEval(curveData);
InitializeUsdGeometry_Impl(this, cacheEntry->ManifestStage.second, cacheEntry->PrimPath, curveData, false,
Settings, &timeEval);
if(this->EnableSaving)
cacheEntry->ManifestStage.second->Save();
}
#endif
#define UPDATE_USDGEOM_ARRAYS(FuncDef) \
FuncDef(this->LogObject, timeVarGeom, uniformGeom, geomData, numPrims, updateEval, timeEval)
#define UPDATE_USDGEOM_PRIMVAR_ARRAYS(FuncDef) \
FuncDef(this, timeVarPrimvars, uniformPrimvars, geomData, numPrims, updateEval, timeEval)
void UsdBridgeUsdWriter::UpdateUsdGeometry(const UsdStagePtr& timeVarStage, const SdfPath& meshPath, const UsdBridgeMeshData& geomData, double timeStep)
{
// To avoid data duplication when using of clip stages, we need to potentially use the scenestage prim for time-uniform data.
UsdGeomMesh uniformGeom = UsdGeomMesh::Get(this->SceneStage, meshPath);
assert(uniformGeom);
UsdGeomPrimvarsAPI uniformPrimvars(uniformGeom);
UsdGeomMesh timeVarGeom = UsdGeomMesh::Get(timeVarStage, meshPath);
assert(timeVarGeom);
UsdGeomPrimvarsAPI timeVarPrimvars(timeVarGeom);
// Update the mesh
UsdBridgeUpdateEvaluator<const UsdBridgeMeshData> updateEval(geomData);
TimeEvaluator<UsdBridgeMeshData> timeEval(geomData, timeStep);
assert((geomData.NumIndices % geomData.FaceVertexCount) == 0);
uint64_t numPrims = int(geomData.NumIndices) / geomData.FaceVertexCount;
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomPoints);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomNormals);
if( Settings.EnableStTexCoords && UsdGeomDataHasTexCoords(geomData) )
{ UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomTexCoords); }
UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomAttributes);
UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomColors);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomIndices);
}
void UsdBridgeUsdWriter::UpdateUsdGeometry(const UsdStagePtr& timeVarStage, const SdfPath& instancerPath, const UsdBridgeInstancerData& geomData, double timeStep)
{
UsdBridgeUpdateEvaluator<const UsdBridgeInstancerData> updateEval(geomData);
TimeEvaluator<UsdBridgeInstancerData> timeEval(geomData, timeStep);
bool useGeomPoints = geomData.UseUsdGeomPoints;
uint64_t numPrims = geomData.NumPoints;
if (useGeomPoints)
{
UsdGeomPoints uniformGeom = UsdGeomPoints::Get(this->SceneStage, instancerPath);
assert(uniformGeom);
UsdGeomPrimvarsAPI uniformPrimvars(uniformGeom);
UsdGeomPoints timeVarGeom = UsdGeomPoints::Get(timeVarStage, instancerPath);
assert(timeVarGeom);
UsdGeomPrimvarsAPI timeVarPrimvars(timeVarGeom);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomPoints);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomInstanceIds);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomWidths);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomOrientNormals);
if( Settings.EnableStTexCoords && UsdGeomDataHasTexCoords(geomData) )
{ UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomTexCoords); }
UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomAttributes);
UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomColors);
}
else
{
UsdGeomPointInstancer uniformGeom = UsdGeomPointInstancer::Get(this->SceneStage, instancerPath);
assert(uniformGeom);
UsdGeomPrimvarsAPI uniformPrimvars(uniformGeom);
UsdGeomPointInstancer timeVarGeom = UsdGeomPointInstancer::Get(timeVarStage, instancerPath);
assert(timeVarGeom);
UsdGeomPrimvarsAPI timeVarPrimvars(timeVarGeom);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomPoints);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomInstanceIds);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomScales);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomOrientations);
if( Settings.EnableStTexCoords && UsdGeomDataHasTexCoords(geomData) )
{ UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomTexCoords); }
UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomAttributes);
UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomColors);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomProtoIndices);
//UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomLinearVelocities);
//UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomAngularVelocities);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomInvisibleIds);
}
}
void UsdBridgeUsdWriter::UpdateUsdGeometry(const UsdStagePtr& timeVarStage, const SdfPath& curvePath, const UsdBridgeCurveData& geomData, double timeStep)
{
// To avoid data duplication when using of clip stages, we need to potentially use the scenestage prim for time-uniform data.
UsdGeomBasisCurves uniformGeom = UsdGeomBasisCurves::Get(this->SceneStage, curvePath);
assert(uniformGeom);
UsdGeomPrimvarsAPI uniformPrimvars(uniformGeom);
UsdGeomBasisCurves timeVarGeom = UsdGeomBasisCurves::Get(timeVarStage, curvePath);
assert(timeVarGeom);
UsdGeomPrimvarsAPI timeVarPrimvars(timeVarGeom);
// Update the curve
UsdBridgeUpdateEvaluator<const UsdBridgeCurveData> updateEval(geomData);
TimeEvaluator<UsdBridgeCurveData> timeEval(geomData, timeStep);
uint64_t numPrims = geomData.NumCurveLengths;
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomPoints);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomNormals);
if( Settings.EnableStTexCoords && UsdGeomDataHasTexCoords(geomData) )
{ UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomTexCoords); }
UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomAttributes);
UPDATE_USDGEOM_PRIMVAR_ARRAYS(UpdateUsdGeomColors);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomWidths);
UPDATE_USDGEOM_ARRAYS(UpdateUsdGeomCurveLengths);
}
void UsdBridgeUsdWriter::UpdateUsdInstancerPrototypes(const SdfPath& instancerPath, const UsdBridgeInstancerRefData& geomRefData,
const SdfPrimPathList& refProtoGeomPrimPaths, const char* protoShapePathRp)
{
UsdGeomPointInstancer uniformGeom = UsdGeomPointInstancer::Get(this->SceneStage, instancerPath);
if(!uniformGeom)
{
UsdBridgeLogMacro(this->LogObject, UsdBridgeLogLevel::WARNING, "Attempt to perform update of prototypes on a prim that is not a UsdGeomPointInstancer.");
return;
}
// Very basic rel update, without any timevarying aspects
UpdateUsdGeomPrototypes(this->LogObject, this->SceneStage, uniformGeom, geomRefData, refProtoGeomPrimPaths, protoShapePathRp);
} | 54,355 | C++ | 42.835484 | 246 | 0.739582 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridge.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridge.h"
#include "UsdBridgeUsdWriter.h"
#include "UsdBridgeCaches.h"
#include "UsdBridgeDiagnosticMgrDelegate.h"
#include <string>
#include <memory>
#define BRIDGE_CACHE Internals->Cache
#define BRIDGE_USDWRITER Internals->UsdWriter
namespace
{
// Parent paths for class definitions (Class path)
const char* const worldPathCp = "worlds";
const char* const instancePathCp = "instances";
const char* const groupPathCp = "groups";
const char* const surfacePathCp = "surfaces";
const char* const volumePathCp = "volumes";
const char* const geometryPathCp = "geometries";
const char* const fieldPathCp = "spatialfields";
const char* const materialPathCp = "materials";
const char* const samplerPathCp = "samplers";
const char* const cameraPathCp = "cameras";
// Parent path extensions for references in parent classes (Reference path)
const char* const instancePathRp = "instances";
const char* const surfacePathRp = "surfaces";
const char* const volumePathRp = "volumes";
const char* const geometryPathRp = "geometry"; // created in surface parent class
const char* const fieldPathRp = "spatialfield"; // created in volume parent class
const char* const materialPathRp = "material"; // created in surface parent class
const char* const samplerPathRp = "samplers"; // created in material parent class (separation from other UsdShader prims in material)
const char* const protoShapePathRp = "protoshapes"; // created in geometry parent class
const char* const protoGeometryPathRp = "protogeometries"; // created in geometry parent class
// Postfixes for prim stage names, also used for manifests
const char* const geomPrimStagePf = "_Geom";
const char* const fieldPrimStagePf = "_Field";
const char* const materialPrimStagePf = "_Material";
const char* const samplerPrimStagePf = "_Sampler";
const char* const cameraPrimStagePf = "_Camera";
// Postfixes for clip stage names
const char* const geomClipPf = "_Geom_";
bool PrimIsNew(const BoolEntryPair& createResult)
{
return !createResult.first.first && !createResult.first.second;
}
}
typedef UsdBridgePrimCacheManager::PrimCacheIterator PrimCacheIterator;
typedef UsdBridgePrimCacheManager::ConstPrimCacheIterator ConstPrimCacheIterator;
struct UsdBridgeInternals
{
UsdBridgeInternals(const UsdBridgeSettings& settings)
: UsdWriter(settings)
{
RefModCallbacks.AtNewRef = [this](UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache){
// Increase the reference count for the child on creation of referencing prim
this->Cache.AddChild(parentCache, childCache);
};
RefModCallbacks.AtRemoveRef = [this](UsdBridgePrimCache* parentCache, UsdBridgePrimCache* childCache) {
this->Cache.RemoveChild(parentCache, childCache);
};
}
~UsdBridgeInternals()
{
if(DiagRemoveFunc)
DiagRemoveFunc(DiagnosticDelegate.get());
}
BoolEntryPair FindOrCreatePrim(const char* category, const char* name, ResourceCollectFunc collectFunc = nullptr);
void FindAndDeletePrim(const UsdBridgeHandle& handle);
template<class T>
const UsdBridgePrimCacheList& ExtractPrimCaches(const T* handles, uint64_t numHandles);
const UsdBridgePrimCacheList& ToCacheList(UsdBridgePrimCache* primCache);
UsdGeomPrimvarsAPI GetBoundGeomPrimvars(const UsdBridgeHandle& material) const;
// Cache
UsdBridgePrimCacheManager Cache;
// USDWriter
UsdBridgeUsdWriter UsdWriter;
// Material->geometry binding suggestion
std::map<UsdBridgePrimCache*, SdfPath> MaterialToGeometryBinding;
// Callbacks
UsdBridgeUsdWriter::RefModFuncs RefModCallbacks;
// Diagnostic Manager
std::unique_ptr<UsdBridgeDiagnosticMgrDelegate> DiagnosticDelegate;
std::function<void (UsdBridgeDiagnosticMgrDelegate*)> DiagRemoveFunc;
// Temp arrays
UsdBridgePrimCacheList TempPrimCaches;
SdfPrimPathList TempPrimPaths;
SdfPrimPathList ProtoPrimPaths;
};
BoolEntryPair UsdBridgeInternals::FindOrCreatePrim(const char* category, const char* name, ResourceCollectFunc collectFunc)
{
assert(TfIsValidIdentifier(name));
UsdBridgePrimCache* primCache = nullptr;
// Find existing entry
ConstPrimCacheIterator it = Cache.FindPrimCache(name);
bool cacheExists = Cache.ValidIterator(it);
bool stageExists = true;
if (cacheExists)
{
// Get the existing entry
primCache = it->second.get();
}
else
{
primCache = Cache.CreatePrimCache(name, UsdWriter.CreatePrimName(name, category), collectFunc)->second.get();
stageExists = !UsdWriter.CreatePrim(primCache->PrimPath);
}
return BoolEntryPair(std::pair<bool,bool>(stageExists, cacheExists), primCache);
}
void UsdBridgeInternals::FindAndDeletePrim(const UsdBridgeHandle& handle)
{
ConstPrimCacheIterator it = Cache.FindPrimCache(handle);
assert(Cache.ValidIterator(it));
UsdBridgePrimCache* cacheEntry = (*it).second.get();
UsdWriter.DeletePrim(cacheEntry);
Cache.RemovePrimCache(it, UsdWriter.LogObject);
}
template<class T>
const UsdBridgePrimCacheList& UsdBridgeInternals::ExtractPrimCaches(const T* handles, uint64_t numHandles)
{
TempPrimCaches.resize(numHandles);
for (uint64_t i = 0; i < numHandles; ++i)
{
TempPrimCaches[i] = this->Cache.ConvertToPrimCache(handles[i]);
}
return TempPrimCaches;
}
const UsdBridgePrimCacheList& UsdBridgeInternals::ToCacheList(UsdBridgePrimCache* primCache)
{
TempPrimCaches.resize(1);
TempPrimCaches[0] = primCache;
return TempPrimCaches;
}
UsdGeomPrimvarsAPI UsdBridgeInternals::GetBoundGeomPrimvars(const UsdBridgeHandle& material) const
{
auto it = MaterialToGeometryBinding.find(material.value);
if(it != MaterialToGeometryBinding.end())
{
const SdfPath& boundGeomPrimPath = it->second;
UsdPrim boundGeomPrim = UsdWriter.GetSceneStage()->GetPrimAtPath(boundGeomPrimPath);
return UsdGeomPrimvarsAPI(boundGeomPrim);
}
return UsdGeomPrimvarsAPI();
}
template<typename HandleType>
bool HasNullHandles(const HandleType* handles, uint64_t numHandles)
{
for(uint64_t i = 0; i < numHandles; ++i)
if(handles[i].value == nullptr)
return true;
return false;
}
UsdBridge::UsdBridge(const UsdBridgeSettings& settings)
: Internals(new UsdBridgeInternals(settings))
, SessionValid(false)
{
SetEnableSaving(true);
}
void UsdBridge::SetExternalSceneStage(SceneStagePtr sceneStage)
{
BRIDGE_USDWRITER.SetExternalSceneStage(UsdStageRefPtr((UsdStage*)sceneStage));
}
void UsdBridge::SetEnableSaving(bool enableSaving)
{
this->EnableSaving = enableSaving;
BRIDGE_USDWRITER.SetEnableSaving(enableSaving);
}
bool UsdBridge::OpenSession(UsdBridgeLogCallback logCallback, void* logUserData)
{
BRIDGE_USDWRITER.LogObject = {logUserData, logCallback};
Internals->DiagnosticDelegate = std::make_unique<UsdBridgeDiagnosticMgrDelegate>(logUserData, logCallback);
Internals->DiagRemoveFunc = [](UsdBridgeDiagnosticMgrDelegate* delegate)
{ TfDiagnosticMgr::GetInstance().RemoveDelegate(delegate); };
TfDiagnosticMgr::GetInstance().AddDelegate(Internals->DiagnosticDelegate.get());
SessionValid = BRIDGE_USDWRITER.InitializeSession();
SessionValid = SessionValid && BRIDGE_USDWRITER.OpenSceneStage();
return SessionValid;
}
void UsdBridge::CloseSession()
{
BRIDGE_USDWRITER.ResetSession();
}
UsdBridge::~UsdBridge()
{
delete Internals;
}
bool UsdBridge::CreateWorld(const char* name, UsdWorldHandle& handle)
{
if (!SessionValid) return false;
// Find or create a cache entry belonging to a prim located under worldPathCp in the usd.
BoolEntryPair createResult = Internals->FindOrCreatePrim(worldPathCp, name);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
if (!cacheExists)
{
this->CreateRootPrimAndAttach(cacheEntry, worldPathCp);
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
bool UsdBridge::CreateInstance(const char* name, UsdInstanceHandle& handle)
{
if (!SessionValid) return false;
BoolEntryPair createResult = Internals->FindOrCreatePrim(instancePathCp, name);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
if (!cacheExists)
{
BRIDGE_USDWRITER.InitializeUsdTransform(cacheEntry);
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
bool UsdBridge::CreateGroup(const char* name, UsdGroupHandle& handle)
{
if (!SessionValid) return false;
BoolEntryPair createResult = Internals->FindOrCreatePrim(groupPathCp, name);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
if (!cacheExists)
{
BRIDGE_USDWRITER.InitializeUsdTransform(cacheEntry);
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
bool UsdBridge::CreateSurface(const char* name, UsdSurfaceHandle& handle)
{
if (!SessionValid) return false;
// Although surface doesn't support transform operations, a transform prim supports timevarying visibility.
BoolEntryPair createResult = Internals->FindOrCreatePrim(surfacePathCp, name);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
if (!cacheExists)
{
BRIDGE_USDWRITER.InitializeUsdTransform(cacheEntry);
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
bool UsdBridge::CreateVolume(const char * name, UsdVolumeHandle& handle)
{
if (!SessionValid) return false;
BoolEntryPair createResult = Internals->FindOrCreatePrim(volumePathCp, name);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
if (!cacheExists)
{
BRIDGE_USDWRITER.InitializeUsdTransform(cacheEntry);
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
template<typename GeomDataType>
bool UsdBridge::CreateGeometryTemplate(const char* name, UsdGeometryHandle& handle, const GeomDataType& geomData)
{
if (!SessionValid) return false;
BoolEntryPair createResult = Internals->FindOrCreatePrim(geometryPathCp, name);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
if (!cacheExists)
{
#ifdef VALUE_CLIP_RETIMING
BRIDGE_USDWRITER.CreateManifestStage(name, geomPrimStagePf, cacheEntry);
#ifndef TIME_CLIP_STAGES
// Default primstage created for clip assetpaths of parents. If this path is not active, individual clip stages are created lazily during data update.
UsdStageRefPtr geomPrimStage = BRIDGE_USDWRITER.FindOrCreatePrimStage(cacheEntry, geomPrimStagePf).second;
BRIDGE_USDWRITER.InitializeUsdGeometry(geomPrimStage, cacheEntry->PrimPath, geomData, false);
#endif
#endif
UsdPrim geomPrim = BRIDGE_USDWRITER.InitializeUsdGeometry(BRIDGE_USDWRITER.GetSceneStage(), cacheEntry->PrimPath, geomData, true);
geomPrim.ApplyAPI<UsdShadeMaterialBindingAPI>();
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
bool UsdBridge::CreateGeometry(const char* name, UsdGeometryHandle& handle, const UsdBridgeMeshData& meshData)
{
return CreateGeometryTemplate<UsdBridgeMeshData>(name, handle, meshData);
}
bool UsdBridge::CreateGeometry(const char* name, UsdGeometryHandle& handle, const UsdBridgeInstancerData& instancerData)
{
return CreateGeometryTemplate<UsdBridgeInstancerData>(name, handle, instancerData);
}
bool UsdBridge::CreateGeometry(const char* name, UsdGeometryHandle& handle, const UsdBridgeCurveData& curveData)
{
return CreateGeometryTemplate<UsdBridgeCurveData>(name, handle, curveData);
}
bool UsdBridge::CreateSpatialField(const char * name, UsdSpatialFieldHandle& handle)
{
if (!SessionValid) return false;
BoolEntryPair createResult = Internals->FindOrCreatePrim(fieldPathCp, name, &ResourceCollectVolume);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
if (!cacheExists)
{
#ifdef VALUE_CLIP_RETIMING
// Create manifest and primstage
BRIDGE_USDWRITER.CreateManifestStage(name, fieldPrimStagePf, cacheEntry);
UsdStageRefPtr volPrimStage = BRIDGE_USDWRITER.FindOrCreatePrimStage(cacheEntry, fieldPrimStagePf).second;
BRIDGE_USDWRITER.InitializeUsdVolume(volPrimStage, cacheEntry->PrimPath, false);
#endif
UsdPrim volumePrim = BRIDGE_USDWRITER.InitializeUsdVolume(BRIDGE_USDWRITER.GetSceneStage(), cacheEntry->PrimPath, true);
volumePrim.ApplyAPI<UsdShadeMaterialBindingAPI>();
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
bool UsdBridge::CreateMaterial(const char* name, UsdMaterialHandle& handle)
{
if (!SessionValid) return false;
// Create the material
BoolEntryPair createResult = Internals->FindOrCreatePrim(materialPathCp, name);
UsdBridgePrimCache* matCacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
UsdMaterialHandle matHandle; matHandle.value = matCacheEntry;
if (!cacheExists)
{
#ifdef VALUE_CLIP_RETIMING
// Create manifest and primstage
BRIDGE_USDWRITER.CreateManifestStage(name, materialPrimStagePf, matCacheEntry);
UsdStageRefPtr matPrimStage = BRIDGE_USDWRITER.FindOrCreatePrimStage(matCacheEntry, materialPrimStagePf).second;
BRIDGE_USDWRITER.InitializeUsdMaterial(matPrimStage, matCacheEntry->PrimPath, false);
#endif
UsdShadeMaterial matPrim = BRIDGE_USDWRITER.InitializeUsdMaterial(BRIDGE_USDWRITER.GetSceneStage(), matCacheEntry->PrimPath, true);
}
handle = matHandle;
return PrimIsNew(createResult);
}
bool UsdBridge::CreateSampler(const char* name, UsdSamplerHandle& handle, UsdBridgeSamplerData::SamplerType type)
{
if (!SessionValid) return false;
BoolEntryPair createResult = Internals->FindOrCreatePrim(samplerPathCp, name, &ResourceCollectSampler);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
if (!cacheExists)
{
#ifdef VALUE_CLIP_RETIMING
// Create manifest and primstage
BRIDGE_USDWRITER.CreateManifestStage(name, samplerPrimStagePf, cacheEntry);
UsdStageRefPtr samplerPrimStage = BRIDGE_USDWRITER.FindOrCreatePrimStage(cacheEntry, samplerPrimStagePf).second;
BRIDGE_USDWRITER.InitializeUsdSampler(samplerPrimStage, cacheEntry->PrimPath, type, false);
#endif
BRIDGE_USDWRITER.InitializeUsdSampler(BRIDGE_USDWRITER.GetSceneStage(), cacheEntry->PrimPath, type, true);
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
bool UsdBridge::CreateCamera(const char* name, UsdCameraHandle& handle)
{
if (!SessionValid) return false;
// Find or create a cache entry belonging to a prim located under worldPathCp in the usd.
BoolEntryPair createResult = Internals->FindOrCreatePrim(cameraPathCp, name);
UsdBridgePrimCache* cacheEntry = createResult.second;
bool cacheExists = createResult.first.second;
// The camera has no manifest, instead the primstage+path is directly referenced by the root camera
// instance prim.
if (!cacheExists)
{
const char* layerId = nullptr;
#ifdef VALUE_CLIP_RETIMING
const UsdStagePair& stagePair = BRIDGE_USDWRITER.FindOrCreatePrimStage(cacheEntry, cameraPrimStagePf);
layerId = stagePair.first.c_str();
UsdStageRefPtr camStage = stagePair.second;
#else
UsdStageRefPtr camStage = BRIDGE_USDWRITER.GetSceneStage();
#endif
BRIDGE_USDWRITER.InitializeUsdCamera(camStage, cacheEntry->PrimPath);
this->CreateRootPrimAndAttach(cacheEntry, cameraPathCp, layerId);
}
handle.value = cacheEntry;
return PrimIsNew(createResult);
}
void UsdBridge::DeleteWorld(UsdWorldHandle handle)
{
if (handle.value == nullptr) return;
UsdBridgePrimCache* worldCache = BRIDGE_CACHE.ConvertToPrimCache(handle);
this->RemoveRootPrimAndDetach(worldCache, worldPathCp);
// Remove the abstract class
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteInstance(UsdInstanceHandle handle)
{
if (handle.value == nullptr) return;
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteGroup(UsdGroupHandle handle)
{
if (handle.value == nullptr) return;
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteSurface(UsdSurfaceHandle handle)
{
if (handle.value == nullptr) return;
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteVolume(UsdVolumeHandle handle)
{
if (handle.value == nullptr) return;
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteGeometry(UsdGeometryHandle handle)
{
if (handle.value == nullptr) return;
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteSpatialField(UsdSpatialFieldHandle handle)
{
if (handle.value == nullptr) return;
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteMaterial(UsdMaterialHandle handle)
{
if (handle.value == nullptr) return;
Internals->MaterialToGeometryBinding.erase(handle.value);
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteSampler(UsdSamplerHandle handle)
{
if (handle.value == nullptr) return;
Internals->FindAndDeletePrim(handle);
}
void UsdBridge::DeleteCamera(UsdCameraHandle handle)
{
if (handle.value == nullptr) return;
UsdBridgePrimCache* cameraCache = BRIDGE_CACHE.ConvertToPrimCache(handle);
this->RemoveRootPrimAndDetach(cameraCache, cameraPathCp);
// Remove the abstract class
Internals->FindAndDeletePrim(handle);
}
template<typename ParentHandleType, typename ChildHandleType>
void UsdBridge::SetNoClipRefs(ParentHandleType parentHandle, const ChildHandleType* childHandles, uint64_t numChildren,
const char* refPathExt, bool timeVarying, double timeStep, bool instanceable)
{
if (parentHandle.value == nullptr) return;
if(HasNullHandles(childHandles, numChildren)) return;
UsdBridgePrimCache* parentCache = BRIDGE_CACHE.ConvertToPrimCache(parentHandle);
const UsdBridgePrimCacheList& childCaches = Internals->ExtractPrimCaches<ChildHandleType>(childHandles, numChildren);
BRIDGE_USDWRITER.ManageUnusedRefs(parentCache, childCaches, refPathExt, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
for (uint64_t i = 0; i < numChildren; ++i)
{
BRIDGE_USDWRITER.AddRef_NoClip(parentCache, childCaches[i], refPathExt, timeVarying, timeStep, instanceable, Internals->RefModCallbacks);
}
}
void UsdBridge::SetInstanceRefs(UsdWorldHandle world, const UsdInstanceHandle* instances, uint64_t numInstances, bool timeVarying, double timeStep)
{
SetNoClipRefs(world, instances, numInstances, instancePathRp, timeVarying, timeStep);
}
void UsdBridge::SetGroupRef(UsdInstanceHandle instance, UsdGroupHandle group, bool timeVarying, double timeStep)
{
if (instance.value == nullptr) return;
if (group.value == nullptr) return;
UsdBridgePrimCache* instanceCache = BRIDGE_CACHE.ConvertToPrimCache(instance);
UsdBridgePrimCache* groupCache = BRIDGE_CACHE.ConvertToPrimCache(group);
constexpr bool instanceable = false;
BRIDGE_USDWRITER.ManageUnusedRefs(instanceCache, Internals->ToCacheList(groupCache), nullptr, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
BRIDGE_USDWRITER.AddRef_NoClip(instanceCache, groupCache, nullptr, timeVarying, timeStep, instanceable, Internals->RefModCallbacks);
}
void UsdBridge::SetSurfaceRefs(UsdWorldHandle world, const UsdSurfaceHandle* surfaces, uint64_t numSurfaces, bool timeVarying, double timeStep)
{
constexpr bool instanceable = true;
SetNoClipRefs(world, surfaces, numSurfaces, surfacePathRp, timeVarying, timeStep, instanceable);
}
void UsdBridge::SetSurfaceRefs(UsdGroupHandle group, const UsdSurfaceHandle* surfaces, uint64_t numSurfaces, bool timeVarying, double timeStep)
{
constexpr bool instanceable = true;
SetNoClipRefs(group, surfaces, numSurfaces, surfacePathRp, timeVarying, timeStep, instanceable);
}
void UsdBridge::SetVolumeRefs(UsdWorldHandle world, const UsdVolumeHandle* volumes, uint64_t numVolumes, bool timeVarying, double timeStep)
{
SetNoClipRefs(world, volumes, numVolumes, volumePathRp, timeVarying, timeStep);
}
void UsdBridge::SetVolumeRefs(UsdGroupHandle group, const UsdVolumeHandle* volumes, uint64_t numVolumes, bool timeVarying, double timeStep)
{
SetNoClipRefs(group, volumes, numVolumes, volumePathRp, timeVarying, timeStep);
}
void UsdBridge::SetGeometryRef(UsdSurfaceHandle surface, UsdGeometryHandle geometry, double timeStep, double geomTimeStep)
{
if (surface.value == nullptr) return;
if (geometry.value == nullptr) return;
UsdBridgePrimCache* surfaceCache = BRIDGE_CACHE.ConvertToPrimCache(surface);
UsdBridgePrimCache* geometryCache = BRIDGE_CACHE.ConvertToPrimCache(geometry);
constexpr bool timeVarying = false; // On a surface, the path to the geometry cannot change over time (ie. is uniformly set), since material is not timevarying either (due to the material binding path rel from the geometry) and the geometry contents itself are already timevarying.
constexpr bool valueClip = true;
constexpr bool clipStages = true;
constexpr bool instanceable = false; // Can only make Xform prims instanceable
BRIDGE_USDWRITER.ManageUnusedRefs(surfaceCache, Internals->ToCacheList(geometryCache), geometryPathRp, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
BRIDGE_USDWRITER.ManageUnusedRefs(surfaceCache, UsdBridgePrimCacheList(), materialPathRp, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
SdfPath refGeomPath = BRIDGE_USDWRITER.AddRef(surfaceCache, geometryCache, geometryPathRp, timeVarying, valueClip, clipStages, geomClipPf, timeStep, geomTimeStep, instanceable, Internals->RefModCallbacks);
BRIDGE_USDWRITER.UnbindMaterialFromGeom(refGeomPath);
}
void UsdBridge::SetGeometryMaterialRef(UsdSurfaceHandle surface, UsdGeometryHandle geometry, UsdMaterialHandle material, double timeStep, double geomTimeStep, double matTimeStep)
{
if (surface.value == nullptr) return;
if (geometry.value == nullptr || material.value == nullptr) return;
UsdBridgePrimCache* surfaceCache = BRIDGE_CACHE.ConvertToPrimCache(surface);
UsdBridgePrimCache* geometryCache = BRIDGE_CACHE.ConvertToPrimCache(geometry);
UsdBridgePrimCache* materialCache = BRIDGE_CACHE.ConvertToPrimCache(material);
constexpr bool timeVarying = false;
constexpr bool valueClip = true;
constexpr bool instanceable = false; // Can only make Xform prims instanceable
// Remove any dangling references
BRIDGE_USDWRITER.ManageUnusedRefs(surfaceCache, Internals->ToCacheList(geometryCache), geometryPathRp, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
BRIDGE_USDWRITER.ManageUnusedRefs(surfaceCache, Internals->ToCacheList(materialCache), materialPathRp, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
// Update the references
SdfPath refGeomPath = BRIDGE_USDWRITER.AddRef(surfaceCache, geometryCache, geometryPathRp, timeVarying, valueClip, true, geomClipPf, timeStep, geomTimeStep, instanceable, Internals->RefModCallbacks); // Can technically be timeVarying, but would be a bit confusing. Instead, timevary the surface.
SdfPath refMatPath = BRIDGE_USDWRITER.AddRef(surfaceCache, materialCache, materialPathRp, timeVarying, valueClip, false, nullptr, timeStep, matTimeStep, instanceable, Internals->RefModCallbacks);
// For updating material attribute reader output types, update the suggested material->geompath mapping.
// Since multiple geometries can be bound to a material, only one is taken, so it is up to the user to ensure correct attribute connection types.
SdfPath& geomPrimPath = geometryCache->PrimPath;
Internals->MaterialToGeometryBinding[material.value] = geomPrimPath;
// Bind the referencing material to the referencing geom prim (as they are within same scope in this usd prim)
BRIDGE_USDWRITER.BindMaterialToGeom(refGeomPath, refMatPath);
}
void UsdBridge::SetSpatialFieldRef(UsdVolumeHandle volume, UsdSpatialFieldHandle field, double timeStep, double fieldTimeStep)
{
if (volume.value == nullptr) return;
if (field.value == nullptr) return;
UsdBridgePrimCache* volumeCache = BRIDGE_CACHE.ConvertToPrimCache(volume);
UsdBridgePrimCache* fieldCache = BRIDGE_CACHE.ConvertToPrimCache(field);
constexpr bool timeVarying = false;
constexpr bool valueClip = true;
constexpr bool clipStages = false;
constexpr bool instanceable = false;
BRIDGE_USDWRITER.ManageUnusedRefs(volumeCache, Internals->ToCacheList(fieldCache), fieldPathRp, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
SdfPath refVolPath = BRIDGE_USDWRITER.AddRef(volumeCache, fieldCache, fieldPathRp, timeVarying, valueClip, clipStages, nullptr, timeStep, fieldTimeStep, instanceable, Internals->RefModCallbacks); // Can technically be timeVarying, but would be a bit confusing. Instead, timevary the volume.
}
void UsdBridge::SetSamplerRefs(UsdMaterialHandle material, const UsdSamplerHandle* samplers, size_t numSamplers, double timeStep, const UsdSamplerRefData* samplerRefData)
{
if (material.value == nullptr) return;
if(HasNullHandles(samplers, numSamplers)) return;
UsdBridgePrimCache* matCache = BRIDGE_CACHE.ConvertToPrimCache(material);
const UsdBridgePrimCacheList& samplerCaches = Internals->ExtractPrimCaches<UsdSamplerHandle>(samplers, numSamplers);
// Sampler references cannot be time-varying (ie. path to sampler cannot change over time - connectToSource doesn't allow for that), and are set on the scenestage prim (so they inherit the type of the sampler prim)
// However, they do allow value clip retiming.
constexpr bool timeVarying = false;
constexpr bool valueClip = true;
constexpr bool clipStages = false;
constexpr bool instanceable = false;
BRIDGE_USDWRITER.ManageUnusedRefs(matCache, samplerCaches, samplerPathRp, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
// Bind sampler and material
SdfPath& matPrimPath = matCache->PrimPath;// .AppendPath(SdfPath(materialAttribPf));
UsdStageRefPtr materialStage = BRIDGE_USDWRITER.GetTimeVarStage(matCache);
Internals->TempPrimPaths.resize(numSamplers);
for (uint64_t i = 0; i < numSamplers; ++i)
{
Internals->TempPrimPaths[i] = BRIDGE_USDWRITER.AddRef(matCache, samplerCaches[i], samplerPathRp, timeVarying, valueClip, clipStages, nullptr, timeStep, samplerRefData[i].TimeStep, instanceable, Internals->RefModCallbacks);
}
BRIDGE_USDWRITER.ConnectSamplersToMaterial(materialStage, matPrimPath, Internals->TempPrimPaths, samplerCaches, samplerRefData, numSamplers, timeStep); // requires world timestep, see implementation
#ifdef VALUE_CLIP_RETIMING
if(this->EnableSaving)
materialStage->Save();
#endif
}
void UsdBridge::SetPrototypeRefs(UsdGeometryHandle geometry, const UsdGeometryHandle* protoGeometries, size_t numProtoGeometries, double timeStep, double* protoTimeSteps)
{
if (geometry.value == nullptr) return;
if(HasNullHandles(protoGeometries, numProtoGeometries)) return;
UsdBridgePrimCache* geometryCache = BRIDGE_CACHE.ConvertToPrimCache(geometry);
const UsdBridgePrimCacheList& protoGeomCaches = Internals->ExtractPrimCaches<UsdGeometryHandle>(protoGeometries, numProtoGeometries);
// Due to prototype rel paths, the path to the prototype itself cannot change. Also, the contents of the prototype itself can already timevary.
constexpr bool timeVarying = false;
constexpr bool valueClip = true;
constexpr bool clipStages = true;
constexpr bool instanceable = false;
BRIDGE_USDWRITER.ManageUnusedRefs(geometryCache, protoGeomCaches, protoGeometryPathRp, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
Internals->ProtoPrimPaths.resize(numProtoGeometries);
for(uint64_t i = 0; i < numProtoGeometries; ++i)
{
Internals->ProtoPrimPaths[i] = BRIDGE_USDWRITER.AddRef(geometryCache, protoGeomCaches[i], protoGeometryPathRp, timeVarying, valueClip, clipStages, geomClipPf, timeStep, protoTimeSteps[i], instanceable, Internals->RefModCallbacks);
}
}
template<typename ParentHandleType>
void UsdBridge::DeleteAllRefs(ParentHandleType parentHandle, const char* refPathExt, bool timeVarying, double timeStep)
{
if (parentHandle.value == nullptr) return;
UsdBridgePrimCache* parentCache = BRIDGE_CACHE.ConvertToPrimCache(parentHandle);
BRIDGE_USDWRITER.RemoveAllRefs(parentCache, refPathExt, timeVarying, timeStep, Internals->RefModCallbacks.AtRemoveRef);
}
void UsdBridge::DeleteInstanceRefs(UsdWorldHandle world, bool timeVarying, double timeStep)
{
DeleteAllRefs(world, instancePathRp, timeVarying, timeStep);
}
void UsdBridge::DeleteGroupRef(UsdInstanceHandle instance, bool timeVarying, double timeStep)
{
DeleteAllRefs(instance, nullptr, timeVarying, timeStep);
}
void UsdBridge::DeleteSurfaceRefs(UsdWorldHandle world, bool timeVarying, double timeStep)
{
DeleteAllRefs(world, surfacePathRp, timeVarying, timeStep);
}
void UsdBridge::DeleteSurfaceRefs(UsdGroupHandle group, bool timeVarying, double timeStep)
{
DeleteAllRefs(group, surfacePathRp, timeVarying, timeStep);
}
void UsdBridge::DeleteVolumeRefs(UsdWorldHandle world, bool timeVarying, double timeStep)
{
DeleteAllRefs(world, volumePathRp, timeVarying, timeStep);
}
void UsdBridge::DeleteVolumeRefs(UsdGroupHandle group, bool timeVarying, double timeStep)
{
DeleteAllRefs(group, volumePathRp, timeVarying, timeStep);
}
void UsdBridge::DeleteGeometryRef(UsdSurfaceHandle surface, double timeStep)
{
DeleteAllRefs(surface, geometryPathRp, false, timeStep);
}
void UsdBridge::DeleteSpatialFieldRef(UsdVolumeHandle volume, double timeStep)
{
DeleteAllRefs(volume, fieldPathRp, false, timeStep);
}
void UsdBridge::DeleteMaterialRef(UsdSurfaceHandle surface, double timeStep)
{
DeleteAllRefs(surface, materialPathRp, false, timeStep);
}
void UsdBridge::DeleteSamplerRefs(UsdMaterialHandle material, double timeStep)
{
DeleteAllRefs(material, samplerPathRp, false, timeStep);
}
void UsdBridge::DeletePrototypeRefs(UsdGeometryHandle geometry, double timeStep)
{
Internals->ProtoPrimPaths.resize(0);
DeleteAllRefs(geometry, protoGeometryPathRp, false, timeStep);
}
void UsdBridge::UpdateBeginEndTime(double timeStep)
{
if (!SessionValid) return;
BRIDGE_USDWRITER.UpdateBeginEndTime(timeStep);
}
void UsdBridge::SetInstanceTransform(UsdInstanceHandle instance, const float* transform, bool timeVarying, double timeStep)
{
if (instance.value == nullptr) return;
UsdBridgePrimCache* cache = BRIDGE_CACHE.ConvertToPrimCache(instance);
SdfPath transformPath = cache->PrimPath;// .AppendPath(SdfPath(transformAttribPf));
BRIDGE_USDWRITER.UpdateUsdTransform(transformPath, transform, timeVarying, timeStep);
}
template<typename GeomDataType>
void UsdBridge::SetGeometryDataTemplate(UsdGeometryHandle geometry, const GeomDataType& geomData, double timeStep)
{
if (geometry.value == nullptr) return;
UsdBridgePrimCache* cache = BRIDGE_CACHE.ConvertToPrimCache(geometry);
SdfPath& geomPath = cache->PrimPath;
#ifdef VALUE_CLIP_RETIMING
if(cache->TimeVarBitsUpdate(geomData.TimeVarying))
BRIDGE_USDWRITER.UpdateUsdGeometryManifest(cache, geomData);
#endif
UsdStageRefPtr geomStage = BRIDGE_USDWRITER.GetTimeVarStage(cache
#ifdef TIME_CLIP_STAGES
, true, geomClipPf, timeStep
, [usdWriter=&BRIDGE_USDWRITER, &geomPath, &geomData] (UsdStageRefPtr geomStage)
{ usdWriter->InitializeUsdGeometry(geomStage, geomPath, geomData, false); }
#endif
);
BRIDGE_USDWRITER.UpdateUsdGeometry(geomStage, geomPath, geomData, timeStep);
#ifdef VALUE_CLIP_RETIMING
if(this->EnableSaving)
geomStage->Save();
#endif
}
void UsdBridge::SetGeometryData(UsdGeometryHandle geometry, const UsdBridgeMeshData& meshData, double timeStep)
{
SetGeometryDataTemplate<UsdBridgeMeshData>(geometry, meshData, timeStep);
}
void UsdBridge::SetGeometryData(UsdGeometryHandle geometry, const UsdBridgeInstancerData& instancerData, double timeStep)
{
SetGeometryDataTemplate<UsdBridgeInstancerData>(geometry, instancerData, timeStep);
}
void UsdBridge::SetGeometryData(UsdGeometryHandle geometry, const UsdBridgeCurveData& curveData, double timeStep)
{
SetGeometryDataTemplate<UsdBridgeCurveData>(geometry, curveData, timeStep);
}
void UsdBridge::SetSpatialFieldData(UsdSpatialFieldHandle field, const UsdBridgeVolumeData& volumeData, double timeStep)
{
if (field.value == nullptr) return;
UsdBridgePrimCache* cache = BRIDGE_CACHE.ConvertToPrimCache(field);
#ifdef VALUE_CLIP_RETIMING
if(cache->TimeVarBitsUpdate(volumeData.TimeVarying))
BRIDGE_USDWRITER.UpdateUsdVolumeManifest(cache, volumeData);
#endif
UsdStageRefPtr volumeStage = BRIDGE_USDWRITER.GetTimeVarStage(cache);
// To avoid data duplication when using of clip stages, we need to potentially use the scenestage prim for time-uniform data.
BRIDGE_USDWRITER.UpdateUsdVolume(volumeStage, cache, volumeData, timeStep);
#ifdef VALUE_CLIP_RETIMING
if(this->EnableSaving)
volumeStage->Save();
#endif
}
void UsdBridge::SetMaterialData(UsdMaterialHandle material, const UsdBridgeMaterialData& matData, double timeStep)
{
if (material.value == nullptr) return;
UsdBridgePrimCache* cache = BRIDGE_CACHE.ConvertToPrimCache(material);
SdfPath& matPrimPath = cache->PrimPath;
#ifdef VALUE_CLIP_RETIMING
if(cache->TimeVarBitsUpdate(matData.TimeVarying))
BRIDGE_USDWRITER.UpdateUsdMaterialManifest(cache, matData);
#endif
UsdStageRefPtr materialStage = BRIDGE_USDWRITER.GetTimeVarStage(cache);
UsdGeomPrimvarsAPI boundGeomPrimvars = Internals->GetBoundGeomPrimvars(material);
BRIDGE_USDWRITER.UpdateUsdMaterial(materialStage, matPrimPath, matData, boundGeomPrimvars, timeStep);
#ifdef VALUE_CLIP_RETIMING
if(this->EnableSaving)
materialStage->Save();
#endif
}
void UsdBridge::SetSamplerData(UsdSamplerHandle sampler, const UsdBridgeSamplerData& samplerData, double timeStep)
{
if (sampler.value == nullptr) return;
UsdBridgePrimCache* cache = BRIDGE_CACHE.ConvertToPrimCache(sampler);
#ifdef VALUE_CLIP_RETIMING
if(cache->TimeVarBitsUpdate(samplerData.TimeVarying))
BRIDGE_USDWRITER.UpdateUsdSamplerManifest(cache, samplerData);
#endif
UsdStageRefPtr samplerStage = BRIDGE_USDWRITER.GetTimeVarStage(cache);
BRIDGE_USDWRITER.UpdateUsdSampler(samplerStage, cache, samplerData, timeStep);
#ifdef VALUE_CLIP_RETIMING
if(this->EnableSaving)
samplerStage->Save();
#endif
}
void UsdBridge::SetCameraData(UsdCameraHandle camera, const UsdBridgeCameraData& cameraData, double timeStep)
{
if (camera.value == nullptr) return;
UsdBridgePrimCache* cache = BRIDGE_CACHE.ConvertToPrimCache(camera);
SdfPath& cameraPath = cache->PrimPath;
bool timeVarHasChanged =
#ifdef VALUE_CLIP_RETIMING
cache->TimeVarBitsUpdate(cameraData.TimeVarying);
#else
false;
#endif
UsdStageRefPtr cameraStage = BRIDGE_USDWRITER.GetTimeVarStage(cache);
BRIDGE_USDWRITER.UpdateUsdCamera(cameraStage, cameraPath, cameraData, timeStep, timeVarHasChanged);
#ifdef VALUE_CLIP_RETIMING
if(this->EnableSaving)
cameraStage->Save();
#endif
}
void UsdBridge::SetPrototypeData(UsdGeometryHandle geometry, const UsdBridgeInstancerRefData& instancerRefData)
{
if (geometry.value == nullptr) return;
UsdBridgePrimCache* geomCache = BRIDGE_CACHE.ConvertToPrimCache(geometry);
SdfPath& geomPath = geomCache->PrimPath;
BRIDGE_USDWRITER.UpdateUsdInstancerPrototypes(geomPath, instancerRefData, Internals->ProtoPrimPaths, protoShapePathRp); // The geometry reference path is already merged into ProtoPrimPaths
}
void UsdBridge::ChangeMaterialInputAttributes(UsdMaterialHandle material, const MaterialInputAttribName* inputAttribs, size_t numInputAttribs, double timeStep, MaterialDMI timeVarying)
{
if (material.value == nullptr) return;
UsdBridgePrimCache* cache = BRIDGE_CACHE.ConvertToPrimCache(material);
SdfPath& matPrimPath = cache->PrimPath;// .AppendPath(SdfPath(samplerAttribPf));
UsdStageRefPtr materialStage = BRIDGE_USDWRITER.GetTimeVarStage(cache);
UsdGeomPrimvarsAPI boundGeomPrimvars = Internals->GetBoundGeomPrimvars(material);
for(int i = 0; i < numInputAttribs; ++i)
BRIDGE_USDWRITER.UpdateAttributeReader(materialStage, matPrimPath, inputAttribs[i].first, inputAttribs[i].second, boundGeomPrimvars, timeStep, timeVarying);
#ifdef VALUE_CLIP_RETIMING
//if(this->EnableSaving)
// materialStage->Save(); // Attrib readers do not have timevarying info at the moment
#endif
}
void UsdBridge::ChangeInAttribute(UsdSamplerHandle sampler, const char* newName, double timeStep, SamplerDMI timeVarying)
{
if (sampler.value == nullptr) return;
UsdBridgePrimCache* cache = BRIDGE_CACHE.ConvertToPrimCache(sampler);
SdfPath& samplerPrimPath = cache->PrimPath;// .AppendPath(SdfPath(samplerAttribPf));
UsdStageRefPtr samplerStage = BRIDGE_USDWRITER.GetTimeVarStage(cache);
BRIDGE_USDWRITER.UpdateInAttribute(samplerStage, samplerPrimPath, newName, timeStep, timeVarying);
#ifdef VALUE_CLIP_RETIMING
if(this->EnableSaving)
samplerStage->Save();
#endif
}
void UsdBridge::SaveScene()
{
if (!SessionValid) return;
if(this->EnableSaving)
BRIDGE_USDWRITER.GetSceneStage()->Save();
}
void UsdBridge::ResetResourceUpdateState()
{
if (!SessionValid) return;
BRIDGE_USDWRITER.ResetSharedResourceModified();
}
void UsdBridge::GarbageCollect()
{
BRIDGE_CACHE.RemoveUnreferencedPrimCaches(
[this](UsdBridgePrimCache* cacheEntry)
{
if(cacheEntry->ResourceCollect)
cacheEntry->ResourceCollect(cacheEntry, BRIDGE_USDWRITER);
BRIDGE_USDWRITER.DeletePrim(cacheEntry);
}
);
if(this->EnableSaving)
BRIDGE_USDWRITER.GetSceneStage()->Save();
}
const char* UsdBridge::GetPrimPath(UsdBridgeHandle* handle)
{
if(handle && handle->value)
{
return handle->value->PrimPath.GetString().c_str();
}
else
return nullptr;
}
void UsdBridge::CreateRootPrimAndAttach(UsdBridgePrimCache* cacheEntry, const char* primPathCp, const char* layerId)
{
BRIDGE_USDWRITER.AddRootPrim(cacheEntry, primPathCp, layerId);
BRIDGE_CACHE.AttachTopLevelPrim(cacheEntry);
}
void UsdBridge::RemoveRootPrimAndDetach(UsdBridgePrimCache* cacheEntry, const char* primPathCp)
{
BRIDGE_CACHE.DetachTopLevelPrim(cacheEntry);
BRIDGE_USDWRITER.RemoveRootPrim(cacheEntry, primPathCp);
}
void UsdBridge::SetConnectionLogVerbosity(int logVerbosity)
{
int logLevel = UsdBridgeRemoteConnection::GetConnectionLogLevelMax() - logVerbosity; // Just invert verbosity to get the level
UsdBridgeRemoteConnection::SetConnectionLogLevel(logLevel);
}
| 38,415 | C++ | 35.071361 | 297 | 0.786958 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeUsdWriter_Common.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeUsdWriterConvenience_h
#define UsdBridgeUsdWriterConvenience_h
#include "UsdBridgeData.h"
#include "UsdBridgeUtils.h"
#include <string>
#include <sstream>
template<typename T>
using TimeEvaluator = UsdBridgeTimeEvaluator<T>;
#define MISC_TOKEN_SEQ \
(Root) \
(extent)
#define ATTRIB_TOKEN_SEQ \
(faceVertexCounts) \
(faceVertexIndices) \
(points) \
(positions) \
(normals) \
(st) \
(attribute0) \
(attribute1) \
(attribute2) \
(attribute3) \
(attribute4) \
(attribute5) \
(attribute6) \
(attribute7) \
(attribute8) \
(attribute9) \
(attribute10) \
(attribute11) \
(attribute12) \
(attribute13) \
(attribute14) \
(attribute15) \
(color) \
(ids) \
(widths) \
(protoIndices) \
(orientations) \
(scales) \
(velocities) \
(angularVelocities) \
(invisibleIds) \
(curveVertexCounts)
#define USDPREVSURF_TOKEN_SEQ \
(UsdPreviewSurface) \
(useSpecularWorkflow) \
(result) \
(surface) \
((PrimVarReader_Float, "UsdPrimvarReader_float")) \
((PrimVarReader_Float2, "UsdPrimvarReader_float2")) \
((PrimVarReader_Float3, "UsdPrimvarReader_float3")) \
((PrimVarReader_Float4, "UsdPrimvarReader_float4")) \
(UsdUVTexture) \
(fallback) \
(r) \
(rg) \
(rgb) \
(black) \
(clamp) \
(repeat) \
(mirror)
#define USDPREVSURF_INPUT_TOKEN_SEQ \
(roughness) \
(opacity) \
(opacityThreshold) \
(metallic) \
(ior) \
(diffuseColor) \
(specularColor) \
(emissiveColor) \
(file) \
(WrapS) \
(WrapT) \
(WrapR) \
(varname)
#define USDPREVSURF_OUTPUT_TOKEN_SEQ \
(result) \
(r) \
(rg) \
(rgb) \
(a)
#define MDL_OUTPUT_TOKEN_SEQ \
(out)
#define MDL_TOKEN_SEQ \
(mdl) \
(OmniPBR) \
(sourceAsset) \
(out) \
(data_lookup_float) \
(data_lookup_float2) \
(data_lookup_float3) \
(data_lookup_float4) \
(data_lookup_int) \
(data_lookup_int2) \
(data_lookup_int3) \
(data_lookup_int4) \
(data_lookup_color) \
(lookup_color) \
(lookup_float) \
(lookup_float3) \
(lookup_float4) \
((xyz, "xyz(float4)")) \
((x, "x(float4)")) \
((y, "y(float4)")) \
((z, "z(float4)")) \
((w, "w(float4)")) \
((construct_color, "construct_color(float3)")) \
((mul_float, "multiply(float,float)")) \
(coord) \
(colorSpace)
#define MDL_INPUT_TOKEN_SEQ \
(reflection_roughness_constant) \
(opacity_constant) \
(opacity_threshold) \
(enable_opacity) \
(metallic_constant) \
(ior_constant) \
(diffuse_color_constant) \
(emissive_color) \
(emissive_intensity) \
(enable_emission) \
(name) \
(tex) \
(wrap_u) \
(wrap_v) \
(wrap_w) \
(a) \
(b) \
#define VOLUME_TOKEN_SEQ \
(density) \
(filePath)
#define INDEX_TOKEN_SEQ \
(nvindex) \
(volume) \
(colormap) \
(Colormap) \
(colormapValues) \
(colormapSource) \
(domain) \
(domainBoundaryMode) \
(clampToEdge)
TF_DECLARE_PUBLIC_TOKENS(
UsdBridgeTokens,
ATTRIB_TOKEN_SEQ
USDPREVSURF_TOKEN_SEQ
USDPREVSURF_INPUT_TOKEN_SEQ
MDL_TOKEN_SEQ
MDL_INPUT_TOKEN_SEQ
VOLUME_TOKEN_SEQ
INDEX_TOKEN_SEQ
MISC_TOKEN_SEQ
);
TF_DECLARE_PUBLIC_TOKENS(
QualifiedInputTokens,
USDPREVSURF_INPUT_TOKEN_SEQ
MDL_INPUT_TOKEN_SEQ
);
TF_DECLARE_PUBLIC_TOKENS(
QualifiedOutputTokens,
USDPREVSURF_OUTPUT_TOKEN_SEQ
MDL_OUTPUT_TOKEN_SEQ
);
namespace constring
{
// Default names
extern const char* const sessionPf;
extern const char* const rootClassName;
extern const char* const rootPrimName;
// Folder names
extern const char* const manifestFolder;
extern const char* const clipFolder;
extern const char* const primStageFolder;
extern const char* const imgFolder;
extern const char* const volFolder;
// Postfixes for auto generated usd subprims
extern const char* const texCoordReaderPrimPf;
extern const char* const psShaderPrimPf;
extern const char* const mdlShaderPrimPf;
extern const char* const mdlOpacityMulPrimPf;
extern const char* const mdlDiffuseOpacityPrimPf;
extern const char* const mdlGraphXYZPrimPf;
extern const char* const mdlGraphColorPrimPf;
extern const char* const mdlGraphXPrimPf;
extern const char* const mdlGraphYPrimPf;
extern const char* const mdlGraphZPrimPf;
extern const char* const mdlGraphWPrimPf;
extern const char* const psSamplerPrimPf;
extern const char* const mdlSamplerPrimPf;
extern const char* const openVDBPrimPf;
extern const char* const protoShapePf;
// Extensions
extern const char* const imageExtension;
extern const char* const vdbExtension;
// Files
extern const char* const fullSceneNameBin;
extern const char* const fullSceneNameAscii;
extern const char* const mdlShaderAssetName;
extern const char* const mdlSupportAssetName;
extern const char* const mdlAuxAssetName;
#ifdef CUSTOM_PBR_MDL
extern const char* const mdlFolder;
extern const char* const opaqueMaterialFile;
extern const char* const transparentMaterialFile;
#endif
#ifdef USE_INDEX_MATERIALS
extern const char* const indexMaterialPf;
extern const char* const indexShaderPf;
extern const char* const indexColorMapPf;
#endif
}
template<typename ArrayType>
ArrayType& GetStaticTempArray()
{
static ArrayType array;
array.resize(0);
return array;
}
namespace
{
size_t FindLength(std::stringstream& strStream)
{
strStream.seekg(0, std::ios::end);
size_t contentSize = strStream.tellg();
strStream.seekg(0, std::ios::beg);
return contentSize;
}
void FormatDirName(std::string& dirName)
{
if (dirName.length() > 0)
{
if (dirName.back() != '/' && dirName.back() != '\\')
dirName.append("/");
}
}
template<typename NormalsType>
void ConvertNormalsToQuaternions(VtQuathArray& quaternions, const void* normals, uint64_t numVertices)
{
GfVec3f from(0.0f, 0.0f, 1.0f);
NormalsType* norms = (NormalsType*)(normals);
for (int i = 0; i < numVertices; ++i)
{
GfVec3f to((float)(norms[i * 3]), (float)(norms[i * 3 + 1]), (float)(norms[i * 3 + 2]));
GfRotation rot(from, to);
const GfQuaternion& quat = rot.GetQuaternion();
quaternions[i] = GfQuath((float)(quat.GetReal()), GfVec3h(quat.GetImaginary()));
}
}
template<typename GeomDataType>
bool UsdGeomDataHasTexCoords(const GeomDataType& geomData)
{
return geomData.Attributes != nullptr &&
geomData.Attributes[0].Data != nullptr &&
(
geomData.Attributes[0].DataType == UsdBridgeType::FLOAT2 ||
geomData.Attributes[0].DataType == UsdBridgeType::DOUBLE2
);
}
TfToken AttribIndexToToken(uint32_t attribIndex)
{
TfToken attribToken;
switch(attribIndex)
{
case 0: attribToken = UsdBridgeTokens->attribute0; break;
case 1: attribToken = UsdBridgeTokens->attribute1; break;
case 2: attribToken = UsdBridgeTokens->attribute2; break;
case 3: attribToken = UsdBridgeTokens->attribute3; break;
case 4: attribToken = UsdBridgeTokens->attribute4; break;
case 5: attribToken = UsdBridgeTokens->attribute5; break;
case 6: attribToken = UsdBridgeTokens->attribute6; break;
case 7: attribToken = UsdBridgeTokens->attribute7; break;
case 8: attribToken = UsdBridgeTokens->attribute8; break;
case 9: attribToken = UsdBridgeTokens->attribute9; break;
case 10: attribToken = UsdBridgeTokens->attribute10; break;
case 11: attribToken = UsdBridgeTokens->attribute11; break;
case 12: attribToken = UsdBridgeTokens->attribute12; break;
case 13: attribToken = UsdBridgeTokens->attribute13; break;
case 14: attribToken = UsdBridgeTokens->attribute14; break;
case 15: attribToken = UsdBridgeTokens->attribute15; break;
default: attribToken = TfToken((std::string("attribute")+std::to_string(attribIndex)).c_str()); break;
}
return attribToken;
}
TfToken TextureWrapToken(UsdBridgeSamplerData::WrapMode wrapMode)
{
TfToken result = UsdBridgeTokens->black;
switch (wrapMode)
{
case UsdBridgeSamplerData::WrapMode::CLAMP:
result = UsdBridgeTokens->clamp;
break;
case UsdBridgeSamplerData::WrapMode::REPEAT:
result = UsdBridgeTokens->repeat;
break;
case UsdBridgeSamplerData::WrapMode::MIRROR:
result = UsdBridgeTokens->mirror;
break;
default:
break;
}
return result;
}
int TextureWrapInt(UsdBridgeSamplerData::WrapMode wrapMode)
{
int result = 3;
switch (wrapMode)
{
case UsdBridgeSamplerData::WrapMode::CLAMP:
result = 0;
break;
case UsdBridgeSamplerData::WrapMode::REPEAT:
result = 1;
break;
case UsdBridgeSamplerData::WrapMode::MIRROR:
result = 2;
break;
default:
break;
}
return result;
}
SdfValueTypeName GetPrimvarArrayType(UsdBridgeType eltType)
{
assert(eltType != UsdBridgeType::UNDEFINED);
SdfValueTypeName result = SdfValueTypeNames->BoolArray;
switch (eltType)
{
case UsdBridgeType::UCHAR:
case UsdBridgeType::CHAR: { result = SdfValueTypeNames->UCharArray; break;}
case UsdBridgeType::USHORT: { result = SdfValueTypeNames->UIntArray; break; }
case UsdBridgeType::SHORT: { result = SdfValueTypeNames->IntArray; break; }
case UsdBridgeType::UINT: { result = SdfValueTypeNames->UIntArray; break; }
case UsdBridgeType::INT: { result = SdfValueTypeNames->IntArray; break; }
case UsdBridgeType::LONG: { result = SdfValueTypeNames->Int64Array; break; }
case UsdBridgeType::ULONG: { result = SdfValueTypeNames->UInt64Array; break; }
case UsdBridgeType::HALF: { result = SdfValueTypeNames->HalfArray; break; }
case UsdBridgeType::FLOAT: { result = SdfValueTypeNames->FloatArray; break; }
case UsdBridgeType::DOUBLE: { result = SdfValueTypeNames->DoubleArray; break; }
case UsdBridgeType::INT2: { result = SdfValueTypeNames->Int2Array; break; }
case UsdBridgeType::HALF2: { result = SdfValueTypeNames->Half2Array; break; }
case UsdBridgeType::FLOAT2: { result = SdfValueTypeNames->Float2Array; break; }
case UsdBridgeType::DOUBLE2: { result = SdfValueTypeNames->Double2Array; break; }
case UsdBridgeType::INT3: { result = SdfValueTypeNames->Int3Array; break; }
case UsdBridgeType::HALF3: { result = SdfValueTypeNames->Half3Array; break; }
case UsdBridgeType::FLOAT3: { result = SdfValueTypeNames->Float3Array; break; }
case UsdBridgeType::DOUBLE3: { result = SdfValueTypeNames->Double3Array; break; }
case UsdBridgeType::INT4: { result = SdfValueTypeNames->Int4Array; break; }
case UsdBridgeType::HALF4: { result = SdfValueTypeNames->Half4Array; break; }
case UsdBridgeType::FLOAT4: { result = SdfValueTypeNames->Float4Array; break; }
case UsdBridgeType::DOUBLE4: { result = SdfValueTypeNames->Double4Array; break; }
case UsdBridgeType::UCHAR2:
case UsdBridgeType::UCHAR3:
case UsdBridgeType::UCHAR4: { result = SdfValueTypeNames->UCharArray; break; }
case UsdBridgeType::CHAR2:
case UsdBridgeType::CHAR3:
case UsdBridgeType::CHAR4: { result = SdfValueTypeNames->UCharArray; break; }
case UsdBridgeType::USHORT2:
case UsdBridgeType::USHORT3:
case UsdBridgeType::USHORT4: { result = SdfValueTypeNames->UIntArray; break; }
case UsdBridgeType::SHORT2:
case UsdBridgeType::SHORT3:
case UsdBridgeType::SHORT4: { result = SdfValueTypeNames->IntArray; break; }
case UsdBridgeType::UINT2:
case UsdBridgeType::UINT3:
case UsdBridgeType::UINT4: { result = SdfValueTypeNames->UIntArray; break; }
case UsdBridgeType::LONG2:
case UsdBridgeType::LONG3:
case UsdBridgeType::LONG4: { result = SdfValueTypeNames->Int64Array; break; }
case UsdBridgeType::ULONG2:
case UsdBridgeType::ULONG3:
case UsdBridgeType::ULONG4: { result = SdfValueTypeNames->UInt64Array; break; }
default: break; //unsupported defaults to bool
};
return result;
}
template<bool PreviewSurface>
const TfToken& GetMaterialShaderInputToken(UsdBridgeMaterialData::DataMemberId dataMemberId)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
if(PreviewSurface)
{
switch(dataMemberId)
{
case DMI::DIFFUSE: { return UsdBridgeTokens->diffuseColor; break; }
case DMI::OPACITY: { return UsdBridgeTokens->opacity; break; }
case DMI::EMISSIVECOLOR: { return UsdBridgeTokens->emissiveColor; break; }
case DMI::ROUGHNESS: { return UsdBridgeTokens->roughness; break; }
case DMI::METALLIC: { return UsdBridgeTokens->metallic; break; }
case DMI::IOR: { return UsdBridgeTokens->ior; break; }
default: assert(false); break;
};
}
else
{
switch(dataMemberId)
{
case DMI::DIFFUSE: { return UsdBridgeTokens->diffuse_color_constant; break; }
case DMI::OPACITY: { return UsdBridgeTokens->opacity_constant; break; }
case DMI::EMISSIVECOLOR: { return UsdBridgeTokens->emissive_color; break; }
case DMI::EMISSIVEINTENSITY: { return UsdBridgeTokens->emissive_intensity; break; }
case DMI::ROUGHNESS: { return UsdBridgeTokens->reflection_roughness_constant; break; }
case DMI::METALLIC: { return UsdBridgeTokens->metallic_constant; break; }
case DMI::IOR: { return UsdBridgeTokens->ior_constant; break; }
default: assert(false); break;
};
}
return UsdBridgeTokens->diffuseColor;
}
template<bool PreviewSurface>
const TfToken& GetMaterialShaderInputQualifiedToken(UsdBridgeMaterialData::DataMemberId dataMemberId)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
if(PreviewSurface)
{
switch(dataMemberId)
{
case DMI::DIFFUSE: { return QualifiedInputTokens->diffuseColor; break; }
case DMI::OPACITY: { return QualifiedInputTokens->opacity; break; }
case DMI::EMISSIVECOLOR: { return QualifiedInputTokens->emissiveColor; break; }
case DMI::ROUGHNESS: { return QualifiedInputTokens->roughness; break; }
case DMI::METALLIC: { return QualifiedInputTokens->metallic; break; }
case DMI::IOR: { return QualifiedInputTokens->ior; break; }
default: assert(false); break;
};
}
else
{
switch(dataMemberId)
{
case DMI::DIFFUSE: { return QualifiedInputTokens->diffuse_color_constant; break; }
case DMI::OPACITY: { return QualifiedInputTokens->opacity_constant; break; }
case DMI::EMISSIVECOLOR: { return QualifiedInputTokens->emissive_color; break; }
case DMI::EMISSIVEINTENSITY: { return QualifiedInputTokens->emissive_intensity; break; }
case DMI::ROUGHNESS: { return QualifiedInputTokens->reflection_roughness_constant; break; }
case DMI::METALLIC: { return QualifiedInputTokens->metallic_constant; break; }
case DMI::IOR: { return QualifiedInputTokens->ior_constant; break; }
default: assert(false); break;
};
}
return QualifiedInputTokens->diffuseColor;
}
template<bool PreviewSurface>
SdfPath GetAttributeReaderPathPf(UsdBridgeMaterialData::DataMemberId dataMemberId)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
const char* const diffuseAttribReaderPrimPf_ps = "diffuseattribreader_ps";
const char* const opacityAttribReaderPrimPf_ps = "opacityattribreader_ps";
const char* const emissiveColorAttribReaderPrimPf_ps = "emissivecolorattribreader_ps";
const char* const emissiveIntensityAttribReaderPrimPf_ps = "emissiveintensityattribreader_ps";
const char* const roughnessAttribReaderPrimPf_ps = "roughnessattribreader_ps";
const char* const metallicAttribReaderPrimPf_ps = "metallicattribreader_ps";
const char* const iorAttribReaderPrimPf_ps = "iorattribreader_ps";
const char* const diffuseAttribReaderPrimPf_mdl = "diffuseattribreader_mdl";
const char* const opacityAttribReaderPrimPf_mdl = "opacityattribreader_mdl";
const char* const emissiveColorAttribReaderPrimPf_mdl = "emissivecolorattribreader_mdl";
const char* const emissiveIntensityAttribReaderPrimPf_mdl = "emissiveintensityattribreader_mdl";
const char* const roughnessAttribReaderPrimPf_mdl = "roughnessattribreader_mdl";
const char* const metallicAttribReaderPrimPf_mdl = "metallicattribreader_mdl";
const char* const iorAttribReaderPrimPf_mdl = "iorattribreader_mdl";
const char* result = nullptr;
if(PreviewSurface)
{
switch(dataMemberId)
{
case DMI::DIFFUSE: { result = diffuseAttribReaderPrimPf_ps; break; }
case DMI::OPACITY: { result = opacityAttribReaderPrimPf_ps; break; }
case DMI::EMISSIVECOLOR: { result = emissiveColorAttribReaderPrimPf_ps; break; }
case DMI::EMISSIVEINTENSITY: { result = emissiveIntensityAttribReaderPrimPf_ps; break; }
case DMI::ROUGHNESS: { result = roughnessAttribReaderPrimPf_ps; break; }
case DMI::METALLIC: { result = metallicAttribReaderPrimPf_ps; break; }
case DMI::IOR: { result = iorAttribReaderPrimPf_ps; break; }
default: assert(false); break;
};
}
else
{
switch(dataMemberId)
{
case DMI::DIFFUSE: { result = diffuseAttribReaderPrimPf_mdl; break; }
case DMI::OPACITY: { result = opacityAttribReaderPrimPf_mdl; break; }
case DMI::EMISSIVECOLOR: { result = emissiveColorAttribReaderPrimPf_mdl; break; }
case DMI::EMISSIVEINTENSITY: { result = emissiveIntensityAttribReaderPrimPf_mdl; break; }
case DMI::ROUGHNESS: { result = roughnessAttribReaderPrimPf_mdl; break; }
case DMI::METALLIC: { result = metallicAttribReaderPrimPf_mdl; break; }
case DMI::IOR: { result = iorAttribReaderPrimPf_mdl; break; }
default: assert(false); break;
};
}
return SdfPath(result);
}
const TfToken& GetPsAttributeReaderId(UsdBridgeMaterialData::DataMemberId dataMemberId)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
switch(dataMemberId)
{
case DMI::DIFFUSE: { return UsdBridgeTokens->PrimVarReader_Float4; break; } // float4 instead of float4, to fix implicit conversion issue in storm
case DMI::OPACITY: { return UsdBridgeTokens->PrimVarReader_Float; break; }
case DMI::EMISSIVECOLOR: { return UsdBridgeTokens->PrimVarReader_Float3; break; }
case DMI::EMISSIVEINTENSITY: { return UsdBridgeTokens->PrimVarReader_Float; break; }
case DMI::ROUGHNESS: { return UsdBridgeTokens->PrimVarReader_Float; break; }
case DMI::METALLIC: { return UsdBridgeTokens->PrimVarReader_Float; break; }
case DMI::IOR: { return UsdBridgeTokens->PrimVarReader_Float; break; }
default: { assert(false); break; }
};
return UsdBridgeTokens->PrimVarReader_Float;
}
const TfToken& GetMdlAttributeReaderSubId(UsdBridgeMaterialData::DataMemberId dataMemberId)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
switch(dataMemberId)
{
case DMI::DIFFUSE: { return UsdBridgeTokens->data_lookup_float4; break; }
case DMI::OPACITY: { return UsdBridgeTokens->data_lookup_float; break; }
case DMI::EMISSIVECOLOR: { return UsdBridgeTokens->data_lookup_color; break; }
case DMI::EMISSIVEINTENSITY: { return UsdBridgeTokens->data_lookup_float; break; }
case DMI::ROUGHNESS: { return UsdBridgeTokens->data_lookup_float; break; }
case DMI::METALLIC: { return UsdBridgeTokens->data_lookup_float; break; }
case DMI::IOR: { return UsdBridgeTokens->data_lookup_float; break; }
default: { assert(false); break; }
};
return UsdBridgeTokens->data_lookup_float4;
}
const TfToken& GetMdlAttributeReaderSubId(const SdfValueTypeName& readerOutputType)
{
if(readerOutputType == SdfValueTypeNames->Float4)
return UsdBridgeTokens->data_lookup_float4;
if(readerOutputType == SdfValueTypeNames->Float3)
return UsdBridgeTokens->data_lookup_float3;
if(readerOutputType == SdfValueTypeNames->Float2)
return UsdBridgeTokens->data_lookup_float2;
if(readerOutputType == SdfValueTypeNames->Float)
return UsdBridgeTokens->data_lookup_float;
if(readerOutputType == SdfValueTypeNames->Int4)
return UsdBridgeTokens->data_lookup_int4;
if(readerOutputType == SdfValueTypeNames->Int3)
return UsdBridgeTokens->data_lookup_int3;
if(readerOutputType == SdfValueTypeNames->Int2)
return UsdBridgeTokens->data_lookup_int2;
if(readerOutputType == SdfValueTypeNames->Int)
return UsdBridgeTokens->data_lookup_int;
if(readerOutputType == SdfValueTypeNames->Color3f)
return UsdBridgeTokens->data_lookup_color;
return UsdBridgeTokens->data_lookup_float4;
}
const SdfValueTypeName& GetAttributeOutputType(UsdBridgeMaterialData::DataMemberId dataMemberId)
{
using DMI = UsdBridgeMaterialData::DataMemberId;
// An educated guess for the type belonging to a particular attribute bound to material inputs
switch(dataMemberId)
{
case DMI::DIFFUSE: { return SdfValueTypeNames->Float4; break; } // Typically bound to the color array, containing rgb and a information.
case DMI::OPACITY: { return SdfValueTypeNames->Float; break; }
case DMI::EMISSIVECOLOR: { return SdfValueTypeNames->Color3f; break; }
case DMI::EMISSIVEINTENSITY: { return SdfValueTypeNames->Float; break; }
case DMI::ROUGHNESS: { return SdfValueTypeNames->Float; break; }
case DMI::METALLIC: { return SdfValueTypeNames->Float; break; }
case DMI::IOR: { return SdfValueTypeNames->Float; break; }
default: assert(false); break;
};
return SdfValueTypeNames->Float;
}
const TfToken& GetSamplerAssetSubId(int numComponents)
{
switch(numComponents)
{
case 1: { return UsdBridgeTokens->lookup_float; break; }
case 4: { return UsdBridgeTokens->lookup_float4; break; }
default: { return UsdBridgeTokens->lookup_float3; break; }
}
return UsdBridgeTokens->lookup_float3;
}
template<bool PreviewSurface>
const TfToken& GetSamplerOutputColorToken(int numComponents)
{
if(PreviewSurface)
{
switch(numComponents)
{
case 1: { return UsdBridgeTokens->r; break; }
case 2: { return UsdBridgeTokens->rg; break; }
default: { return UsdBridgeTokens->rgb; break; } // The alpha component is always separate
}
}
return UsdBridgeTokens->out;
}
template<bool PreviewSurface>
const SdfValueTypeName& GetSamplerOutputColorType(int numComponents)
{
if(PreviewSurface)
{
switch(numComponents)
{
case 1: { return SdfValueTypeNames->Float; break; }
case 2: { return SdfValueTypeNames->Float2; break; }
default: { return SdfValueTypeNames->Float3; break; } // The alpha component is always separate
}
}
else
{
switch(numComponents)
{
case 1: { return SdfValueTypeNames->Float; break; }
case 4: { return SdfValueTypeNames->Float4; break; }
default: { return SdfValueTypeNames->Float3; break; }
}
}
return SdfValueTypeNames->Float3;
}
template<class T>
T GetOrDefinePrim(const UsdStageRefPtr& stage, const SdfPath& path)
{
T prim = T::Get(stage, path);
if (!prim)
prim = T::Define(stage, path);
assert(prim);
return prim;
}
template<typename ValueType>
void ClearAndSetUsdAttribute(const UsdAttribute& attribute, const ValueType& value, const UsdTimeCode& timeCode, bool clearAttrib)
{
if(clearAttrib)
attribute.Clear();
attribute.Set(value, timeCode);
}
void ClearUsdAttributes(const UsdAttribute& uniformAttrib, const UsdAttribute& timeVarAttrib, bool timeVaryingUpdate)
{
#ifdef TIME_BASED_CACHING
#ifdef VALUE_CLIP_RETIMING
// Step could be performed to keep timeVar stage more in sync, but removal of attrib from manifest makes this superfluous
//if (!timeVaryingUpdate && timeVarGeom)
//{
// timeVarAttrib.ClearAtTime(timeEval.TimeCode);
//}
#ifdef OMNIVERSE_CREATE_WORKAROUNDS
if(timeVaryingUpdate && uniformAttrib)
{
// Create considers the referenced uniform prims as a stronger opinion than timeVarying clip values (against the spec, see 'value resolution').
// Just remove the referenced uniform opinion altogether.
uniformAttrib.ClearAtTime(TimeEvaluator<bool>::DefaultTime);
}
#endif
#else // !VALUE_CLIP_RETIMING
// Uniform and timeVar geoms are the same. In case of uniform values, make sure the timesamples are cleared out.
if(!timeVaryingUpdate && timeVarAttrib)
{
timeVarAttrib.Clear();
}
#endif
#endif
}
// Array assignment
template<class ArrayType>
void AssignArrayToPrimvar(const void* data, size_t numElements, const UsdTimeCode& timeCode, ArrayType* usdArray)
{
using ElementType = typename ArrayType::ElementType;
ElementType* typedData = (ElementType*)data;
usdArray->assign(typedData, typedData + numElements);
}
template<class ArrayType>
void AssignArrayToPrimvarFlatten(const void* data, UsdBridgeType dataType, size_t numElements, const UsdTimeCode& timeCode, ArrayType* usdArray)
{
int elementMultiplier = UsdBridgeTypeNumComponents(dataType);
size_t numFlattenedElements = numElements * elementMultiplier;
AssignArrayToPrimvar<ArrayType>(data, numFlattenedElements, timeCode, usdArray);
}
template<class ArrayType, class EltType>
void AssignArrayToPrimvarConvert(const void* data, size_t numElements, const UsdTimeCode& timeCode, ArrayType* usdArray)
{
using ElementType = typename ArrayType::ElementType;
EltType* typedData = (EltType*)data;
usdArray->resize(numElements);
for (int i = 0; i < numElements; ++i)
{
(*usdArray)[i] = ElementType(typedData[i]);
}
}
template<class ArrayType, class EltType>
void AssignArrayToPrimvarConvertFlatten(const void* data, UsdBridgeType dataType, size_t numElements, const UsdTimeCode& timeCode, ArrayType* usdArray)
{
int elementMultiplier = UsdBridgeTypeNumComponents(dataType);
size_t numFlattenedElements = numElements * elementMultiplier;
AssignArrayToPrimvarConvert<ArrayType, EltType>(data, numFlattenedElements, timeCode, usdArray);
}
template<typename ArrayType, typename EltType>
void Expand1ToVec3(const void* data, uint64_t numElements, const UsdTimeCode& timeCode, ArrayType* usdArray)
{
usdArray->resize(numElements);
const EltType* typedInput = reinterpret_cast<const EltType*>(data);
for (int i = 0; i < numElements; ++i)
{
(*usdArray)[i] = typename ArrayType::ElementType(typedInput[i], typedInput[i], typedInput[i]);
}
}
template<typename InputEltType, int numComponents>
void ExpandToColor(const void* data, uint64_t numElements, const UsdTimeCode& timeCode, VtVec4fArray* usdArray)
{
usdArray->resize(numElements);
const InputEltType* typedInput = reinterpret_cast<const InputEltType*>(data);
// No memcopies, as input is not guaranteed to be of float type
if(numComponents == 1)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(typedInput[i], 0.0f, 0.0f, 1.0f);
if(numComponents == 2)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(typedInput[i*2], typedInput[i*2+1], 0.0f, 1.0f);
if(numComponents == 3)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(typedInput[i*3], typedInput[i*3+1], typedInput[i*3+2], 1.0f);
}
template<typename InputEltType, int numComponents>
void ExpandToColorNormalize(const void* data, uint64_t numElements, const UsdTimeCode& timeCode, VtVec4fArray* usdArray)
{
usdArray->resize(numElements);
const InputEltType* typedInput = reinterpret_cast<const InputEltType*>(data);
double normFactor = 1.0 / (double)std::numeric_limits<InputEltType>::max(); // float may not be enough for uint32_t
// No memcopies, as input is not guaranteed to be of float type
if(numComponents == 1)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(typedInput[i]*normFactor, 0.0f, 0.0f, 1.0f);
if(numComponents == 2)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(typedInput[i*2]*normFactor, typedInput[i*2+1]*normFactor, 0.0f, 1.0f);
if(numComponents == 3)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(typedInput[i*3]*normFactor, typedInput[i*3+1]*normFactor, typedInput[i*3+2]*normFactor, 1.0f);
if(numComponents == 4)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(typedInput[i*4]*normFactor, typedInput[i*4+1]*normFactor, typedInput[i*4+2]*normFactor, typedInput[i*4+3]*normFactor);
}
template<int numComponents>
void ExpandSRGBToColor(const void* data, uint64_t numElements, const UsdTimeCode& timeCode, VtVec4fArray* usdArray)
{
usdArray->resize(numElements);
const unsigned char* typedInput = reinterpret_cast<const unsigned char*>(data);
float normFactor = 1.0f / 255.0f;
const float* srgbTable = ubutils::SrgbToLinearTable();
// No memcopies, as input is not guaranteed to be of float type
if(numComponents == 1)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(srgbTable[typedInput[i]], 0.0f, 0.0f, 1.0f);
if(numComponents == 2)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(srgbTable[typedInput[i*2]], 0.0f, 0.0f, typedInput[i*2+1]*normFactor); // Alpha is linear
if(numComponents == 3)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(srgbTable[typedInput[i*3]], srgbTable[typedInput[i*3+1]], srgbTable[typedInput[i*3+2]], 1.0f);
if(numComponents == 4)
for (int i = 0; i < numElements; ++i)
(*usdArray)[i] = GfVec4f(srgbTable[typedInput[i*4]], srgbTable[typedInput[i*4+1]], srgbTable[typedInput[i*4+2]], typedInput[i*4+3]*normFactor);
}
}
#define CREATE_REMOVE_TIMEVARYING_ATTRIB(_prim, _dataMemberId, _token, _type) \
if(!timeEval || timeEval->IsTimeVarying(_dataMemberId)) \
_prim.CreateAttribute(_token, _type); \
else \
_prim.RemoveProperty(_token);
#define CREATE_REMOVE_TIMEVARYING_ATTRIB_QUALIFIED(_dataMemberId, _CreateFunc, _token) \
if(!timeEval || timeEval->IsTimeVarying(_dataMemberId)) \
attribCreatePrim._CreateFunc(); \
else \
attribRemovePrim.RemoveProperty(_token);
#define SET_TIMEVARYING_ATTRIB(_timeVaryingUpdate, _timeVarAttrib, _uniformAttrib, _value) \
if(_timeVaryingUpdate) \
_timeVarAttrib.Set(_value, timeEval.TimeCode); \
else \
_uniformAttrib.Set(_value, timeEval.Default());
#define ASSIGN_SET_PRIMVAR if(setPrimvar) arrayPrimvar.Set(usdArray, timeCode)
#define ASSIGN_PRIMVAR_MACRO(ArrayType) \
ArrayType& usdArray = GetStaticTempArray<ArrayType>(); AssignArrayToPrimvar<ArrayType>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_FLATTEN_MACRO(ArrayType) \
ArrayType& usdArray = GetStaticTempArray<ArrayType>(); AssignArrayToPrimvarFlatten<ArrayType>(arrayData, arrayDataType, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_CONVERT_MACRO(ArrayType, EltType) \
ArrayType& usdArray = GetStaticTempArray<ArrayType>(); AssignArrayToPrimvarConvert<ArrayType, EltType>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_CONVERT_FLATTEN_MACRO(ArrayType, EltType) \
ArrayType& usdArray = GetStaticTempArray<ArrayType>(); AssignArrayToPrimvarConvertFlatten<ArrayType, EltType>(arrayData, arrayDataType, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_CUSTOM_ARRAY_MACRO(ArrayType, customArray) \
ArrayType& usdArray = customArray; AssignArrayToPrimvar<ArrayType>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_CONVERT_CUSTOM_ARRAY_MACRO(ArrayType, EltType, customArray) \
ArrayType& usdArray = customArray; AssignArrayToPrimvarConvert<ArrayType, EltType>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_1EXPAND3(ArrayType, EltType) \
ArrayType& usdArray = GetStaticTempArray<ArrayType>(); Expand1ToVec3<ArrayType, EltType>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_1EXPAND_COL(EltType) \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandToColor<EltType, 1>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_2EXPAND_COL(EltType) \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandToColor<EltType, 2>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_3EXPAND_COL(EltType) \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandToColor<EltType, 3>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_1EXPAND_NORMALIZE_COL(EltType) \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandToColorNormalize<EltType, 1>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_2EXPAND_NORMALIZE_COL(EltType) \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandToColorNormalize<EltType, 2>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_3EXPAND_NORMALIZE_COL(EltType) \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandToColorNormalize<EltType, 3>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_4EXPAND_NORMALIZE_COL(EltType) \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandToColorNormalize<EltType, 4>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_1EXPAND_SGRB() \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandSRGBToColor<1>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_2EXPAND_SGRB() \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandSRGBToColor<2>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_3EXPAND_SGRB() \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandSRGBToColor<3>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define ASSIGN_PRIMVAR_MACRO_4EXPAND_SGRB() \
VtVec4fArray& usdArray = GetStaticTempArray<VtVec4fArray>(); ExpandSRGBToColor<4>(arrayData, arrayNumElements, timeCode, &usdArray); ASSIGN_SET_PRIMVAR
#define GET_USDARRAY_REF usdArrayRef = &usdArray
namespace
{
// Assigns color data array to VtVec4fArray primvar
VtVec4fArray* AssignColorArrayToPrimvar(const UsdBridgeLogObject& logObj, const void* arrayData, size_t arrayNumElements, UsdBridgeType arrayType, UsdTimeCode timeCode, const UsdAttribute& arrayPrimvar, bool setPrimvar = true)
{
VtVec4fArray* usdArrayRef = nullptr;
switch (arrayType)
{
case UsdBridgeType::UCHAR: {ASSIGN_PRIMVAR_MACRO_1EXPAND_NORMALIZE_COL(uint8_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::UCHAR2: {ASSIGN_PRIMVAR_MACRO_2EXPAND_NORMALIZE_COL(uint8_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::UCHAR3: {ASSIGN_PRIMVAR_MACRO_3EXPAND_NORMALIZE_COL(uint8_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::UCHAR4: {ASSIGN_PRIMVAR_MACRO_4EXPAND_NORMALIZE_COL(uint8_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::UCHAR_SRGB_R: {ASSIGN_PRIMVAR_MACRO_1EXPAND_SGRB(); GET_USDARRAY_REF; break; }
case UsdBridgeType::UCHAR_SRGB_RA: {ASSIGN_PRIMVAR_MACRO_2EXPAND_SGRB(); GET_USDARRAY_REF; break; }
case UsdBridgeType::UCHAR_SRGB_RGB: {ASSIGN_PRIMVAR_MACRO_3EXPAND_SGRB(); GET_USDARRAY_REF; break; }
case UsdBridgeType::UCHAR_SRGB_RGBA: {ASSIGN_PRIMVAR_MACRO_4EXPAND_SGRB(); GET_USDARRAY_REF; break; }
case UsdBridgeType::USHORT: {ASSIGN_PRIMVAR_MACRO_1EXPAND_NORMALIZE_COL(uint16_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::USHORT2: {ASSIGN_PRIMVAR_MACRO_2EXPAND_NORMALIZE_COL(uint16_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::USHORT3: {ASSIGN_PRIMVAR_MACRO_3EXPAND_NORMALIZE_COL(uint16_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::USHORT4: {ASSIGN_PRIMVAR_MACRO_4EXPAND_NORMALIZE_COL(uint16_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::UINT: {ASSIGN_PRIMVAR_MACRO_1EXPAND_NORMALIZE_COL(uint32_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::UINT2: {ASSIGN_PRIMVAR_MACRO_2EXPAND_NORMALIZE_COL(uint32_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::UINT3: {ASSIGN_PRIMVAR_MACRO_3EXPAND_NORMALIZE_COL(uint32_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::UINT4: {ASSIGN_PRIMVAR_MACRO_4EXPAND_NORMALIZE_COL(uint32_t); GET_USDARRAY_REF; break; }
case UsdBridgeType::FLOAT: {ASSIGN_PRIMVAR_MACRO_1EXPAND_COL(float); GET_USDARRAY_REF; break; }
case UsdBridgeType::FLOAT2: {ASSIGN_PRIMVAR_MACRO_2EXPAND_COL(float); GET_USDARRAY_REF; break; }
case UsdBridgeType::FLOAT3: {ASSIGN_PRIMVAR_MACRO_3EXPAND_COL(float); GET_USDARRAY_REF; break; }
case UsdBridgeType::FLOAT4: {ASSIGN_PRIMVAR_MACRO(VtVec4fArray); GET_USDARRAY_REF; break; }
case UsdBridgeType::DOUBLE: {ASSIGN_PRIMVAR_MACRO_1EXPAND_COL(double); GET_USDARRAY_REF; break; }
case UsdBridgeType::DOUBLE2: {ASSIGN_PRIMVAR_MACRO_2EXPAND_COL(double); GET_USDARRAY_REF; break; }
case UsdBridgeType::DOUBLE3: {ASSIGN_PRIMVAR_MACRO_3EXPAND_COL(double); GET_USDARRAY_REF; break; }
case UsdBridgeType::DOUBLE4: {ASSIGN_PRIMVAR_CONVERT_MACRO(VtVec4fArray, GfVec4d); GET_USDARRAY_REF; break; }
default: { UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom color primvar is not of type (UCHAR/USHORT/UINT/FLOAT/DOUBLE)(1/2/3/4) or UCHAR_SRGB_<X>."); break; }
}
return usdArrayRef;
}
void AssignAttribArrayToPrimvar(const UsdBridgeLogObject& logObj, const void* arrayData, UsdBridgeType arrayDataType, size_t arrayNumElements, const UsdAttribute& arrayPrimvar, const UsdTimeCode& timeCode)
{
bool setPrimvar = true;
switch (arrayDataType)
{
case UsdBridgeType::UCHAR: { ASSIGN_PRIMVAR_MACRO(VtUCharArray); break; }
case UsdBridgeType::UCHAR_SRGB_R: { ASSIGN_PRIMVAR_MACRO(VtUCharArray); break; }
case UsdBridgeType::CHAR: { ASSIGN_PRIMVAR_MACRO(VtUCharArray); break; }
case UsdBridgeType::USHORT: { ASSIGN_PRIMVAR_CONVERT_MACRO(VtUIntArray, short); break; }
case UsdBridgeType::SHORT: { ASSIGN_PRIMVAR_CONVERT_MACRO(VtIntArray, unsigned short); break; }
case UsdBridgeType::UINT: { ASSIGN_PRIMVAR_MACRO(VtUIntArray); break; }
case UsdBridgeType::INT: { ASSIGN_PRIMVAR_MACRO(VtIntArray); break; }
case UsdBridgeType::LONG: { ASSIGN_PRIMVAR_MACRO(VtInt64Array); break; }
case UsdBridgeType::ULONG: { ASSIGN_PRIMVAR_MACRO(VtUInt64Array); break; }
case UsdBridgeType::HALF: { ASSIGN_PRIMVAR_MACRO(VtHalfArray); break; }
case UsdBridgeType::FLOAT: { ASSIGN_PRIMVAR_MACRO(VtFloatArray); break; }
case UsdBridgeType::DOUBLE: { ASSIGN_PRIMVAR_MACRO(VtDoubleArray); break; }
case UsdBridgeType::INT2: { ASSIGN_PRIMVAR_MACRO(VtVec2iArray); break; }
case UsdBridgeType::FLOAT2: { ASSIGN_PRIMVAR_MACRO(VtVec2fArray); break; }
case UsdBridgeType::DOUBLE2: { ASSIGN_PRIMVAR_MACRO(VtVec2dArray); break; }
case UsdBridgeType::INT3: { ASSIGN_PRIMVAR_MACRO(VtVec3iArray); break; }
case UsdBridgeType::FLOAT3: { ASSIGN_PRIMVAR_MACRO(VtVec3fArray); break; }
case UsdBridgeType::DOUBLE3: { ASSIGN_PRIMVAR_MACRO(VtVec3dArray); break; }
case UsdBridgeType::INT4: { ASSIGN_PRIMVAR_MACRO(VtVec4iArray); break; }
case UsdBridgeType::FLOAT4: { ASSIGN_PRIMVAR_MACRO(VtVec4fArray); break; }
case UsdBridgeType::DOUBLE4: { ASSIGN_PRIMVAR_MACRO(VtVec4dArray); break; }
case UsdBridgeType::UCHAR2:
case UsdBridgeType::UCHAR3:
case UsdBridgeType::UCHAR4: { ASSIGN_PRIMVAR_FLATTEN_MACRO(VtUCharArray); break; }
case UsdBridgeType::UCHAR_SRGB_RA:
case UsdBridgeType::UCHAR_SRGB_RGB:
case UsdBridgeType::UCHAR_SRGB_RGBA: { ASSIGN_PRIMVAR_FLATTEN_MACRO(VtUCharArray); break; }
case UsdBridgeType::CHAR2:
case UsdBridgeType::CHAR3:
case UsdBridgeType::CHAR4: { ASSIGN_PRIMVAR_FLATTEN_MACRO(VtUCharArray); break; }
case UsdBridgeType::USHORT2:
case UsdBridgeType::USHORT3:
case UsdBridgeType::USHORT4: { ASSIGN_PRIMVAR_CONVERT_FLATTEN_MACRO(VtUIntArray, short); break; }
case UsdBridgeType::SHORT2:
case UsdBridgeType::SHORT3:
case UsdBridgeType::SHORT4: { ASSIGN_PRIMVAR_CONVERT_FLATTEN_MACRO(VtIntArray, unsigned short); break; }
case UsdBridgeType::UINT2:
case UsdBridgeType::UINT3:
case UsdBridgeType::UINT4: { ASSIGN_PRIMVAR_FLATTEN_MACRO(VtUIntArray); break; }
case UsdBridgeType::LONG2:
case UsdBridgeType::LONG3:
case UsdBridgeType::LONG4: { ASSIGN_PRIMVAR_FLATTEN_MACRO(VtInt64Array); break; }
case UsdBridgeType::ULONG2:
case UsdBridgeType::ULONG3:
case UsdBridgeType::ULONG4: { ASSIGN_PRIMVAR_FLATTEN_MACRO(VtUInt64Array); break; }
case UsdBridgeType::HALF2:
case UsdBridgeType::HALF3:
case UsdBridgeType::HALF4: { ASSIGN_PRIMVAR_FLATTEN_MACRO(VtHalfArray); break; }
default: {UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "UsdGeom Attribute<Index> primvar copy does not support source data type: " << arrayDataType) break; }
};
}
}
#endif | 41,699 | C | 40.205534 | 228 | 0.708746 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeTimeEvaluator.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeTimeEvaluator_h
#define UsdBridgeTimeEvaluator_h
#include "usd.h"
PXR_NAMESPACE_USING_DIRECTIVE
template<class T>
class UsdBridgeTimeEvaluator
{
public:
UsdBridgeTimeEvaluator(const T& data, double timeStep)
: Data(data)
, TimeCode(timeStep)
{
}
UsdBridgeTimeEvaluator(const T& data)
: Data(data)
{
}
const UsdTimeCode& Eval(typename T::DataMemberId member) const
{
#ifdef TIME_BASED_CACHING
if ((Data.TimeVarying & member) != T::DataMemberId::NONE)
return TimeCode;
else
#endif
return DefaultTime;
}
bool IsTimeVarying(typename T::DataMemberId member) const
{
#ifdef TIME_BASED_CACHING
return ((Data.TimeVarying & member) != T::DataMemberId::NONE);
#else
return false;
#endif
}
UsdTimeCode Default() const { return DefaultTime; }
const T& Data;
const UsdTimeCode TimeCode;
static const UsdTimeCode DefaultTime;
};
template<class T>
const UsdTimeCode UsdBridgeTimeEvaluator<T>::DefaultTime = UsdTimeCode::Default();
template<>
class UsdBridgeTimeEvaluator<bool>
{
public:
UsdBridgeTimeEvaluator(bool timeVarying, double timeStep)
: TimeVarying(timeVarying)
, TimeCode(timeStep)
{
}
const UsdTimeCode& Eval() const
{
#ifdef TIME_BASED_CACHING
if (TimeVarying)
return TimeCode;
else
#endif
return DefaultTime;
}
UsdTimeCode Default() const { return DefaultTime; }
const bool TimeVarying;
const UsdTimeCode TimeCode;
static const UsdTimeCode DefaultTime;
};
#endif | 1,583 | C | 18.555555 | 82 | 0.720152 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeDiagnosticMgrDelegate.cpp |
// Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeDiagnosticMgrDelegate.h"
bool UsdBridgeDiagnosticMgrDelegate::OutputEnabled = false;
UsdBridgeDiagnosticMgrDelegate::UsdBridgeDiagnosticMgrDelegate(void* logUserData, UsdBridgeLogCallback logCallback)
: LogUserData(logUserData)
, LogCallback(logCallback)
{}
void UsdBridgeDiagnosticMgrDelegate::IssueError(TfError const& err)
{
LogTfMessage(UsdBridgeLogLevel::ERR, err);
}
void UsdBridgeDiagnosticMgrDelegate::IssueFatalError(TfCallContext const& context,
std::string const& msg)
{
std::string message = TfStringPrintf(
"[USD Internal error]: %s in %s at line %zu of %s",
msg.c_str(), context.GetFunction(), context.GetLine(), context.GetFile()
);
LogMessage(UsdBridgeLogLevel::ERR, message);
}
void UsdBridgeDiagnosticMgrDelegate::IssueStatus(TfStatus const& status)
{
LogTfMessage(UsdBridgeLogLevel::STATUS, status);
}
void UsdBridgeDiagnosticMgrDelegate::IssueWarning(TfWarning const& warning)
{
LogTfMessage(UsdBridgeLogLevel::WARNING, warning);
}
void UsdBridgeDiagnosticMgrDelegate::LogTfMessage(UsdBridgeLogLevel level, TfDiagnosticBase const& diagBase)
{
std::string message = TfStringPrintf(
"[USD Internal Message]: %s with error code %s in %s at line %zu of %s",
diagBase.GetCommentary().c_str(),
TfDiagnosticMgr::GetCodeName(diagBase.GetDiagnosticCode()).c_str(),
diagBase.GetContext().GetFunction(),
diagBase.GetContext().GetLine(),
diagBase.GetContext().GetFile()
);
LogMessage(level, message);
}
void UsdBridgeDiagnosticMgrDelegate::LogMessage(UsdBridgeLogLevel level, const std::string& message)
{
if(OutputEnabled)
LogCallback(level, LogUserData, message.c_str());
} | 1,776 | C++ | 30.175438 | 115 | 0.756194 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/UsdBridgeCaches.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "usd.h"
PXR_NAMESPACE_USING_DIRECTIVE
#include "UsdBridgeCaches.h"
#include "UsdBridgeUtils.h"
#ifdef VALUE_CLIP_RETIMING
constexpr double UsdBridgePrimCache::PrimStageTimeCode;
#endif
UsdBridgePrimCache::UsdBridgePrimCache(const SdfPath& pp, const SdfPath& nm, ResourceCollectFunc cf)
: PrimPath(pp), Name(nm), ResourceCollect(cf)
#ifndef NDEBUG
, Debug_Name(nm.GetString())
#endif
{
if(cf)
{
ResourceKeys = std::make_unique<ResourceContainer>();
}
}
UsdBridgePrimCache* UsdBridgePrimCache::GetChildCache(const TfToken& nameToken)
{
auto it = std::find_if(this->Children.begin(), this->Children.end(),
[&nameToken](UsdBridgePrimCache* cache) -> bool { return cache->PrimPath.GetNameToken() == nameToken; });
return (it == this->Children.end()) ? nullptr : *it;
}
#ifdef TIME_BASED_CACHING
void UsdBridgePrimCache::SetChildVisibleAtTime(const UsdBridgePrimCache* childCache, double timeCode)
{
auto childIt = std::find(this->Children.begin(), this->Children.end(), childCache);
if(childIt == this->Children.end())
return;
std::vector<double>& visibleTimes = ChildVisibleAtTimes[childIt - this->Children.begin()];
auto timeIt = std::find(visibleTimes.begin(), visibleTimes.end(), timeCode);
if(timeIt == visibleTimes.end())
visibleTimes.push_back(timeCode);
}
bool UsdBridgePrimCache::SetChildInvisibleAtTime(const UsdBridgePrimCache* childCache, double timeCode)
{
auto childIt = std::find(this->Children.begin(), this->Children.end(), childCache);
if(childIt == this->Children.end())
return false;
std::vector<double>& visibleTimes = ChildVisibleAtTimes[childIt - this->Children.begin()];
auto timeIt = std::find(visibleTimes.begin(), visibleTimes.end(), timeCode);
if(timeIt != visibleTimes.end())
{
// Remove the time at visibleTimeIdx
size_t visibleTimeIdx = timeIt - visibleTimes.begin();
visibleTimes[visibleTimeIdx] = visibleTimes.back();
visibleTimes.pop_back();
return visibleTimes.size() == 0; // Return child removed && empty
}
return false;
}
#endif
#ifdef VALUE_CLIP_RETIMING
const UsdStagePair& UsdBridgePrimCache::GetPrimStagePair() const
{
auto it = ClipStages.find(PrimStageTimeCode);
assert(it != ClipStages.end());
return it->second;
}
#endif
void UsdBridgePrimCache::AddChild(UsdBridgePrimCache* child)
{
if(std::find(this->Children.begin(), this->Children.end(), child) != this->Children.end())
return;
this->Children.push_back(child);
child->IncRef();
#ifdef TIME_BASED_CACHING
this->ChildVisibleAtTimes.resize(this->Children.size());
#endif
}
void UsdBridgePrimCache::RemoveChild(UsdBridgePrimCache* child)
{
auto it = std::find(this->Children.begin(), this->Children.end(), child);
// Allow for find to fail; in the case where the bridge is recreated and destroyed,
// a child prim exists which doesn't have a ref in the cache.
if(it != this->Children.end())
{
#ifdef TIME_BASED_CACHING
size_t foundIdx = it - this->Children.begin();
if(foundIdx != this->ChildVisibleAtTimes.size()-1)
this->ChildVisibleAtTimes[foundIdx] = std::move(this->ChildVisibleAtTimes.back());
this->ChildVisibleAtTimes.pop_back();
#endif
child->DecRef();
*it = this->Children.back();
this->Children.pop_back();
}
}
void UsdBridgePrimCache::RemoveUnreferencedChildTree(AtRemoveFunc atRemove)
{
assert(this->RefCount == 0);
atRemove(this);
for (UsdBridgePrimCache* child : this->Children)
{
child->DecRef();
if(child->RefCount == 0)
child->RemoveUnreferencedChildTree(atRemove);
}
this->Children.clear();
}
bool UsdBridgePrimCache::AddResourceKey(UsdBridgeResourceKey key) // copy by value
{
assert(ResourceKeys);
bool newEntry = std::find(ResourceKeys->begin(), ResourceKeys->end(), key) == ResourceKeys->end();
if(newEntry)
ResourceKeys->push_back(key);
return newEntry;
}
UsdBridgePrimCacheManager::ConstPrimCacheIterator UsdBridgePrimCacheManager::FindPrimCache(const UsdBridgeHandle& handle) const
{
ConstPrimCacheIterator it = std::find_if(
UsdPrimCaches.begin(),
UsdPrimCaches.end(),
[handle](const PrimCacheContainer::value_type& cmp) -> bool { return cmp.second.get() == handle.value; }
);
return it;
}
UsdBridgePrimCacheManager::ConstPrimCacheIterator UsdBridgePrimCacheManager::CreatePrimCache(const std::string& name, const std::string& fullPath, ResourceCollectFunc collectFunc)
{
SdfPath nameSuffix(name);
SdfPath primPath(fullPath);
// Create new cache entry
std::unique_ptr<UsdBridgePrimCache> cacheEntry = std::make_unique<UsdBridgePrimCache>(primPath, nameSuffix, collectFunc);
return UsdPrimCaches.emplace(name, std::move(cacheEntry)).first;
}
void UsdBridgePrimCacheManager::AttachTopLevelPrim(UsdBridgePrimCache* primCache)
{
primCache->IncRef();
}
void UsdBridgePrimCacheManager::DetachTopLevelPrim(UsdBridgePrimCache* primCache)
{
primCache->DecRef();
}
void UsdBridgePrimCacheManager::AddChild(UsdBridgePrimCache* parent, UsdBridgePrimCache* child)
{
parent->AddChild(child);
}
void UsdBridgePrimCacheManager::RemoveChild(UsdBridgePrimCache* parent, UsdBridgePrimCache* child)
{
parent->RemoveChild(child);
}
void UsdBridgePrimCacheManager::RemovePrimCache(ConstPrimCacheIterator it, UsdBridgeLogObject& LogObject)
{
if(it->second->RefCount > 0)
{
UsdBridgeLogMacro(LogObject, UsdBridgeLogLevel::WARNING, "Primcache removed for object named: " << it->first << ", but refs still exist");
}
UsdPrimCaches.erase(it);
}
void UsdBridgePrimCacheManager::RemoveUnreferencedPrimCaches(AtRemoveFunc atRemove)
{
// First recursively remove all the child references for unreferenced prims
// Can only be performed at garbage collect.
// If this is done during RemoveChild, an unreferenced parent cannot subsequently be revived with an AddChild.
PrimCacheContainer::iterator it = UsdPrimCaches.begin();
while (it != UsdPrimCaches.end())
{
if (it->second->RefCount == 0)
{
it->second->RemoveUnreferencedChildTree(atRemove);
}
++it;
}
// Now delete all prims without references from the cache
it = UsdPrimCaches.begin();
while (it != UsdPrimCaches.end())
{
if (it->second->RefCount == 0)
it = UsdPrimCaches.erase(it);
else
++it;
}
} | 6,353 | C++ | 29.84466 | 179 | 0.728947 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Mdl/UsdBridgeMdlStrings.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeMacros.h"
#ifdef CUSTOM_PBR_MDL
static const char Mdl_PBRBase_string[] = R"matstrdelim(
/*****************************************************************************
* Copyright 1986-2017 NVIDIA Corporation. All rights reserved.
******************************************************************************
MDL MATERIALS ARE PROVIDED PURSUANT TO AN END USER LICENSE AGREEMENT,
WHICH WAS ACCEPTED IN ORDER TO GAIN ACCESS TO THIS FILE. IN PARTICULAR,
THE MDL MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL NVIDIA
CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING
ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
THE USE OR INABILITY TO USE THE MDL MATERIALS OR FROM OTHER DEALINGS IN
THE MDL MATERIALS.
*/
mdl 1.4;
import df::*;
import state::*;
import math::*;
import base::*;
import tex::*;
import anno::*;
import ::nvidia::core_definitions::file_texture;
import ::nvidia::core_definitions::normalmap_texture;
// -------------------- HELPER FUNCTIONS ----------------------
base::texture_return multiply_colors(
color color_1 = color(1.0, 1.0, 1.0),
color color_2 = color(.5, .5, .5),
float weight = 1.0
) [[
anno::hidden()
]]
{
return base::blend_color_layers(
layers: base::color_layer[](
base::color_layer(
layer_color: color_2,
weight: weight,
mode: base::color_layer_multiply
)),
base: color_1
);
}
float4 vertex_color_from_coordinate(int VertexColorCoordinateIndex)
[[
anno::description("Vertex Color for float2 PrimVar"),
anno::noinline()
]]
{
// Kit only supports 4 uv sets, 2 uvs are available to vertex color. if vertex color index is invalid, output the constant WHITE color intead
return (VertexColorCoordinateIndex > 2) ? float4(1.0f) : float4(state::texture_coordinate(VertexColorCoordinateIndex).x, state::texture_coordinate(VertexColorCoordinateIndex).y, state::texture_coordinate(VertexColorCoordinateIndex+1).x, state::texture_coordinate(VertexColorCoordinateIndex+1).y);
}
color get_translucent_tint(color base_color, float opacity)
[[
anno::description("base color of Basic translucent"),
anno::noinline()
]]
{
return math::lerp(color(1.0), base_color, opacity);
}
tex::wrap_mode get_wrap_mode(int wrap_constant)
{
tex::wrap_mode result = tex::wrap_clip;
switch(wrap_constant)
{
case 1: result = tex::wrap_clamp; break;
case 2: result = tex::wrap_repeat; break;
case 3: result = tex::wrap_mirrored_repeat; break;
default: break;
}
return result;
}
// -------------------- MATERIAL ----------------------
export material OmniPBR(
color diffuse_color_constant = color(0.2f)
[[
anno::display_name("Base Color"),
anno::description("This is the base color"),
anno::in_group("Albedo")
]],
uniform texture_2d diffuse_texture = texture_2d()
[[
anno::display_name("Albedo Map"),
anno::in_group("Albedo")
]],
float albedo_desaturation = float(0.0)
[[
anno::display_name("Albedo Desaturation"),
anno::soft_range(float(0.0f), float(1.0f)),
anno::description("Desaturates the diffuse color"),
anno::in_group("Albedo")
]],
float albedo_add = float(0.0)
[[
anno::display_name("Albedo Add"),
anno::soft_range(float(-1.0f), float(1.0f)),
anno::description("Adds a constant value to the diffuse color "),
anno::in_group("Albedo")
]],
float albedo_brightness = float(1.0)
[[
anno::display_name("Albedo Brightness"),
anno::soft_range(float(0.0f), float(1.0f)),
anno::description("Multiplier for the diffuse color "),
anno::in_group("Albedo")
]],
color diffuse_tint = color(1.0f)
[[
anno::display_name("Color Tint"),
anno::description("When enabled, this color value is multiplied over the final albedo color"),
anno::in_group("Albedo")
]],
// -------------------- REFLECTIVITY/METALLIC ----------------------
float reflection_roughness_constant = 0.5f
[[
anno::display_name("Roughness Amount"),
anno::hard_range(0.0,1.),
anno::description("Higher roughness values lead to more blurry reflections"),
anno::in_group("Reflectivity")
]],
float reflection_roughness_texture_influence = 0.0f
[[
anno::display_name("Roughness Map Influence"),
anno::hard_range(0.0, 1.),
anno::description("Blends between the constant value and the lookup of the roughness texture"),
anno::in_group("Reflectivity")
]],
uniform texture_2d reflection_roughness_texture = texture_2d()
[[
anno::display_name("Roughness Map"),
anno::in_group("Reflectivity")
]],
float metallic_constant = 0.f
[[
anno::display_name("Metallic Amount"),
anno::hard_range(0.0,1.),
anno::description("Metallic Material"),
anno::in_group("Reflectivity")
]],
float metallic_texture_influence = 0.0f
[[
anno::display_name("Metallic Map Influence"),
anno::hard_range(0.0, 1.),
anno::description("Blends between the constant value and the lookup of the metallic texture"),
anno::in_group("Reflectivity")
]],
uniform texture_2d metallic_texture = texture_2d()
[[
anno::display_name("Metallic Map"),
anno::in_group("Reflectivity")
]],
float specular_level = float(0.5)
[[
anno::display_name("Specular"),
anno::soft_range(float(0.0f), float(1.0f)),
anno::description("The specular level (intensity) of the material"),
anno::in_group("Reflectivity")
]],
// -------------------- EMISSIVE ----------------------
uniform bool enable_emission = false
[[
anno::display_name("Enable Emission"),
anno::description("Enables the emission of light from the material"),
anno::in_group("Emissive")
]],
color emissive_color = color(1.0, 0.1, 0.1)
[[
anno::enable_if("enable_emission == true"),
anno::display_name("Emissive Color"),
anno::description("The emission color"),
anno::in_group("Emissive")
]],
uniform texture_2d emissive_mask_texture = texture_2d()
[[
anno::enable_if("enable_emission == true"),
anno::display_name("Emissive Mask map"),
anno::description("The texture masking the emissive color"),
anno::in_group("Emissive")
]],
uniform float emissive_intensity = 40.f
[[
anno::enable_if("enable_emission == true"),
anno::display_name("Emissive Intensity"),
anno::description("Intensity of the emission"),
anno::in_group("Emissive")
]],
// Opacity Map
uniform bool enable_opacity_texture = false
[[
anno::display_name("Enable Opacity Texture"),
anno::description("Enables or disbales the usage of the opacity texture map"),
anno::in_group("Opacity")
]],
uniform float opacity_constant = 1.0f
[[
anno::enable_if("enable_opacity_texture == true"),
anno::hard_range(0.0, 1.0),
anno::display_name("Opacity Amount"),
anno::description("Amount of Opacity"),
anno::in_group("Opacity")
]],
uniform texture_2d opacity_texture = texture_2d()
[[
anno::enable_if("enable_opacity_texture==true"),
anno::display_name("Opacity Map"),
anno::in_group("Opacity")
]],
uniform float ior_constant = 1.f
[[
anno::enable_if("opacity_constant < 1.0"),
anno::display_name("Index of Refraction"),
anno::description("Index of Refraction for transparent materials"),
anno::in_group("Opacity")
]],
// -------------------- Normal ----------------------
uniform float bump_factor = 1.f
[[
anno::display_name("Normal Map Strength"),
anno::description("Strength of normal map."),
anno::in_group("Normal")
]],
uniform texture_2d normalmap_texture = texture_2d()
[[
anno::display_name("Normal Map"),
anno::description("Enables the usage of the normalmap texture"),
anno::in_group("Normal")
]],
// -------------------- Vertex Colors ----------------------
uniform int vertexcolor_coordinate_index = -1
[[
anno::display_name("Vertex Color Texture Coordinate Index"),
anno::description("Index for texture coordinate with vertex colors"),
anno::in_group("VertexColor")
]],
// -------------------- Wrapping ----------------------
uniform int diffuse_wrapmode_u = 2
[[
anno::display_name("Diffuse Wrapping Mode U"),
anno::description("Wrapping mode along u axis of diffuse_texture, see get_wrap_mode"),
anno::in_group("Texture")
]],
uniform int diffuse_wrapmode_v = 2
[[
anno::display_name("Diffuse Wrapping Mode V"),
anno::description("Wrapping mode along v axis of diffuse_texture, see get_wrap_mode"),
anno::in_group("Texture")
]]
)
[[
anno::display_name("PBR Opacity"),
anno::description("PBR material, supports opacity"),
anno::version( 1, 0, 0),
anno::author("NVIDIA CORPORATION"),
anno::key_words(string[]("PBR", "generic"))
]]
= let{
// -------------------- Texcoord --------------------
int uv_space_index = 0;
base::texture_coordinate_info uvw = base::coordinate_source(
coordinate_system: base::texture_coordinate_uvw,
texture_space: uv_space_index );
base::texture_coordinate_info transformed_uvw = uvw;
// -------------------- Base texture --------------------
base::texture_return base_lookup = base::file_texture(
texture: diffuse_texture,
color_offset: color(albedo_add),
color_scale: color(albedo_brightness),
mono_source: base::mono_luminance,
uvw: transformed_uvw,
wrap_u: get_wrap_mode(diffuse_wrapmode_u),
wrap_v: get_wrap_mode(diffuse_wrapmode_v),
clip: false);
float alpha = tex::texture_isvalid(diffuse_texture) ? base::file_texture(
texture: diffuse_texture,
mono_source: base::mono_alpha,
uvw: transformed_uvw,
wrap_u: get_wrap_mode(diffuse_wrapmode_u),
wrap_v: get_wrap_mode(diffuse_wrapmode_v),
clip: false).mono
: 1.0;
// -------------------- Rougness/Reflection --------------------
base::texture_return roughness_lookup = base::file_texture(
texture: reflection_roughness_texture,
mono_source: base::mono_average,
uvw: transformed_uvw,
clip: false
);
float roughness_selection = roughness_lookup.mono;
float reflection_roughness_1 = math::lerp(reflection_roughness_constant, roughness_selection, reflection_roughness_texture_influence);
color desaturated_base = math::lerp(base_lookup.tint, color(base_lookup.mono), albedo_desaturation);
// -------------------- Metallic --------------------
base::texture_return metallic_lookup = base::file_texture(
texture: metallic_texture,
color_offset: color(0.0, 0.0, 0.0),
color_scale: color(1.0, 1.0, 1.0),
mono_source: base::mono_average,
uvw: transformed_uvw,
clip: false
);
// Choose between ORM or metallic map
float metallic_selection = metallic_lookup.mono;
// blend between the constant metallic value and the map lookup
float metallic = math::lerp(metallic_constant, metallic_selection, metallic_texture_influence);
// -------------------- Emissive --------------------
color emissive_mask = tex::texture_isvalid(emissive_mask_texture) ?
base::file_texture(
texture: emissive_mask_texture,
color_offset: color(0.0, 0.0, 0.0),
color_scale: color(1.0, 1.0, 1.0),
mono_source: base::mono_average,
uvw: transformed_uvw,
clip: false).tint
: color(1.0);
// -------------------- Normal --------------------
float3 the_normal = tex::texture_isvalid(normalmap_texture) ?
base::tangent_space_normal_texture(
texture: normalmap_texture,
factor: bump_factor,
uvw: transformed_uvw
//flip_tangent_u: false,
//flip_tangent_v: true
) : state::normal() ;
float3 final_normal = the_normal;
// -------------------- Opacity --------------------
float final_opacity = enable_opacity_texture ?
base::file_texture(
texture: opacity_texture,
mono_source: base::mono_average,
uvw: transformed_uvw ).mono
: (opacity_constant > 0 ? opacity_constant*alpha : alpha);
// -------------------- Establish base color --------------------
float4 vcData = vertex_color_from_coordinate(vertexcolor_coordinate_index);
color diffuse_color = tex::texture_isvalid(diffuse_texture) ? desaturated_base :
((vertexcolor_coordinate_index >= 0 && vertexcolor_coordinate_index < state::texture_space_max()) ? color(vcData.x, vcData.y, vcData.z) : diffuse_color_constant);
color tinted_diffuse_color = multiply_colors(diffuse_color, diffuse_tint, 1.0).tint;
color final_base_color = tinted_diffuse_color;
// -------------------- Construct bsdf --------------------
float reflection_roughness_sq = reflection_roughness_1*reflection_roughness_1;
)matstrdelim";
static const char Mdl_PBRBase_string_opaque[] = R"matstrdelim(
bsdf diffuse_bsdf = df::diffuse_reflection_bsdf(
tint: final_base_color,
roughness: 0.f );
bsdf ggx_smith_bsdf = df::microfacet_ggx_smith_bsdf(
roughness_u: reflection_roughness_sq,
roughness_v: reflection_roughness_sq,
tint: color(1.0, 1.0, 1.0),
mode: df::scatter_reflect );
bsdf custom_curve_layer_bsdf = df::custom_curve_layer(
normal_reflectivity: 0.08,
grazing_reflectivity: 1.0,
exponent: 5.0,
weight: specular_level,
layer: ggx_smith_bsdf,
base: diffuse_bsdf );
bsdf directional_factor_bsdf = df::directional_factor(
normal_tint: final_base_color,
grazing_tint: final_base_color,
exponent: 3.0f,
base: ggx_smith_bsdf );
bsdf final_bsdf = df::weighted_layer(
weight: metallic,
layer: directional_factor_bsdf,
base: custom_curve_layer_bsdf );
} in material(
surface: material_surface(
scattering: final_bsdf,
emission: material_emission (
df::diffuse_edf(),
intensity: enable_emission? emissive_color * emissive_mask * color(emissive_intensity) : color(0)
)
),
geometry: material_geometry(
normal: final_normal,
cutout_opacity: final_opacity
)
);
)matstrdelim";
static const char Mdl_PBRBase_string_translucent[] = R"matstrdelim(
bsdf ggx_smith_bsdf = df::microfacet_ggx_smith_bsdf(
roughness_u: reflection_roughness_sq,
roughness_v: reflection_roughness_sq,
tint: get_translucent_tint(base_color: final_base_color, opacity: final_opacity),
mode: df::scatter_reflect_transmit
);
bsdf directional_factor_bsdf = df::directional_factor(
normal_tint: final_base_color,
grazing_tint: final_base_color,
exponent: 3.0f,
base: ggx_smith_bsdf );
bsdf final_bsdf = df::weighted_layer(
weight: metallic,
layer: directional_factor_bsdf,
base: ggx_smith_bsdf );
} in material(
thin_walled: true,
ior: color(ior_constant),
surface: material_surface(
scattering: final_bsdf,
emission: material_emission (
df::diffuse_edf(),
intensity: enable_emission? emissive_color * emissive_mask * color(emissive_intensity) : color(0)
)
),
geometry: material_geometry(
normal: final_normal,
cutout_opacity: 1.0
)
);
)matstrdelim";
#endif
| 16,262 | C | 32.462963 | 297 | 0.604846 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Volume/UsdBridgeVolumeWriter.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeVolumeWriter_h
#define UsdBridgeVolumeWriter_h
#include "UsdBridgeData.h"
#ifdef _WIN32
#define USDDevice_DECL __cdecl
#ifdef UsdBridge_Volume_EXPORTS
#define USDDevice_INTERFACE __declspec(dllexport)
#else
#define USDDevice_INTERFACE __declspec(dllimport)
#endif
#else
#define USDDevice_DECL
#define USDDevice_INTERFACE
#endif
class UsdBridgeVolumeWriterI
{
public:
virtual bool Initialize(const UsdBridgeLogObject& logObj) = 0;
virtual void ToVDB(const UsdBridgeVolumeData& volumeData) = 0;
virtual void GetSerializedVolumeData(const char*& data, size_t& size) = 0;
virtual void SetConvertDoubleToFloat(bool convert) = 0;
virtual void Release() = 0; // Accommodate change of CRT
};
extern "C" USDDevice_INTERFACE UsdBridgeVolumeWriterI* USDDevice_DECL Create_VolumeWriter();
#endif | 908 | C | 22.921052 | 92 | 0.770925 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Volume/UsdBridgeVolumeWriter.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeVolumeWriter.h"
#include <memory>
class UsdBridgeVolumeWriterInternals;
class UsdBridgeVolumeWriter : public UsdBridgeVolumeWriterI
{
public:
UsdBridgeVolumeWriter();
~UsdBridgeVolumeWriter();
bool Initialize(const UsdBridgeLogObject& logObj) override;
void ToVDB(const UsdBridgeVolumeData& volumeData) override;
void GetSerializedVolumeData(const char*& data, size_t& size) override;
void SetConvertDoubleToFloat(bool convert) override { ConvertDoubleToFloat = convert; }
void Release() override;
UsdBridgeLogObject LogObject;
protected:
bool ConvertDoubleToFloat = true;
#ifdef USE_OPENVDB
std::unique_ptr<UsdBridgeVolumeWriterInternals> Internals;
#endif
};
extern "C" UsdBridgeVolumeWriterI* USDDevice_DECL Create_VolumeWriter()
{
return new UsdBridgeVolumeWriter();
}
void UsdBridgeVolumeWriter::Release()
{
delete this;
}
#ifdef USE_OPENVDB
#include "openvdb/openvdb.h"
#include "openvdb/io/Stream.h"
#include "openvdb/tools/Dense.h"
#include "openvdb/tools/GridTransformer.h"
#include "openvdb/tree/ValueAccessor.h"
#include <assert.h>
#include <limits>
#include <sstream>
#include "UsdBridgeUtils.h"
#ifdef USDBRIDGE_VOL_FLOAT1_OUTPUT
using ColorGridOutType = openvdb::FloatGrid;
#else
using ColorGridOutType = openvdb::Vec3fGrid;
#endif
using OpacityGridOutType = openvdb::FloatGrid;
class UsdBridgeVolumeWriterInternals
{
public:
UsdBridgeVolumeWriterInternals()
//: GridStream(std::ios::in | std::ios::out)
{}
~UsdBridgeVolumeWriterInternals()
{}
std::ostream& ResetStream()
{
//GridStream.clear(); // Bug in OpenVDB prevents reuse of stream
delete GridStream;
GridStream = new std::stringstream(std::ios::in | std::ios::out);
return *GridStream;
}
const char* GetStreamData()
{
if(!GridStream)
return nullptr;
StreamData = GridStream->str();
return StreamData.c_str();
}
size_t GetStreamDataSize()
{
return StreamData.length();
}
protected:
std::stringstream* GridStream = nullptr;
std::string StreamData;
};
struct TfTransformInput
{
ColorGridOutType::Ptr colorGrid;
OpacityGridOutType::Ptr opacityGrid;
const UsdBridgeVolumeData& volumeData;
const openvdb::CoordBBox& bBox;
};
template<typename DataType, typename OpType, typename TransformerType>
struct TfTransform
{
public:
TfTransform(const UsdBridgeVolumeData& volumeData, const openvdb::CoordBBox& bBox, const TransformerType& transformer)
: Transformer(transformer)
, VolData(static_cast<const DataType*>(volumeData.Data))
, Dims(bBox.max() + openvdb::math::Coord(1, 1, 1)) //Bbox is inclusive, dims are exclusive
, InvValueRangeMag(OpType(1.0) / (OpType)(volumeData.TfData.TfValueRange[1] - volumeData.TfData.TfValueRange[0]))
, ValueRangeMin((OpType)(volumeData.TfData.TfValueRange[0]))
{
}
inline void operator()(const typename TransformerType::Iter& iter) const
{
openvdb::math::Coord coord = iter.getCoord();
assert(coord.x() >= 0 && coord.x() < Dims.x() &&
coord.y() >= 0 && coord.y() < Dims.y() &&
coord.z() >= 0 && coord.z() < Dims.z());
size_t linearIndex = Dims.y() * Dims.x() * coord.z() + Dims.x() * coord.y() + coord.x();
const DataType* curVal = VolData + linearIndex;
OpType ucVal = (((OpType)(*curVal)) - this->ValueRangeMin) * this->InvValueRangeMag;
float normValue = (float)((ucVal < (OpType)0.0) ? (OpType)0.0 : ((ucVal > (OpType)1.0) ? (OpType)1.0 : ucVal));
Transformer.Transform(normValue, iter);
}
/*
inline void operator()(
const openvdb::FloatGrid::ValueOnCIter& iter,
openvdb::tree::ValueAccessor<TreeOutType>& accessor)
{
openvdb::Vec4f transformedColor;
transformColor(*iter, transformedColor);
if (iter.isVoxelValue())
{ // set a single voxel
accessor.setValue(iter.getCoord(), transformedColor);
}
else
{ // fill an entire tile
openvdb::CoordBBox bbox;
iter.getBoundingBox(bbox);
accessor.getTree()->fill(bbox, transformedColor);
}
}
*/
const TransformerType& Transformer;
const DataType* VolData;
openvdb::math::Coord Dims;
OpType InvValueRangeMag;
OpType ValueRangeMin;
};
struct TfColorTransformer
{
public:
typedef ColorGridOutType::ValueOnIter Iter;
TfColorTransformer(const UsdBridgeTfData& tfData)
: TfColors(static_cast<const float*>(tfData.TfColors))
, NumTfColors(tfData.TfNumColors)
{
}
inline void Transform(float normValue, const Iter& iter) const
{
openvdb::Vec3f transformedColor;
float colorIndexF = normValue * (this->NumTfColors - 1);
float floorColor;
float fracColor = std::modf(colorIndexF, &floorColor);
int colIdx0 = int(floorColor);
int colIdx1 = colIdx0 + (colIdx0 != (this->NumTfColors - 1));
const float* color0 = this->TfColors + 3 * colIdx0;
const float* color1 = this->TfColors + 3 * colIdx1;
float OneMinFracColor = 1.0f - fracColor;
transformedColor[0] = fracColor * color1[0] + OneMinFracColor * color0[0];
transformedColor[1] = fracColor * color1[1] + OneMinFracColor * color0[1];
transformedColor[2] = fracColor * color1[2] + OneMinFracColor * color0[2];
#ifdef FLOAT1_OUTPUT
iter.setValue(transformedColor.length());
#else
iter.setValue(transformedColor);
#endif
}
const float* TfColors;
int NumTfColors;
};
struct TfOpacityTransformer
{
public:
typedef OpacityGridOutType::ValueOnIter Iter;
TfOpacityTransformer(const UsdBridgeTfData& tfData)
: TfOpacities(static_cast<const float*>(tfData.TfOpacities))
, NumTfOpacities(tfData.TfNumOpacities)
{
}
inline void Transform(float normValue, const Iter& iter) const
{
float opacityIndexF = normValue * (this->NumTfOpacities - 1);
float floorOpacity;
float fracOpacity = std::modf(opacityIndexF, &floorOpacity);
int opacityIdx0 = int(floorOpacity);
int opacityIdx1 = opacityIdx0 + (opacityIdx0 != (this->NumTfOpacities - 1));
float finalOpacity = fracOpacity * this->TfOpacities[opacityIdx1] +
(1.0f - fracOpacity) * this->TfOpacities[opacityIdx0];
iter.setValue(finalOpacity);
}
const float* TfOpacities;
int NumTfOpacities;
};
template<typename DataType, typename OpType>
void TfTransformCall(TfTransformInput& tfTransformInput)
{
TfColorTransformer colorTransformer(tfTransformInput.volumeData.TfData);
TfTransform<DataType, OpType, TfColorTransformer> tfColorTransform(tfTransformInput.volumeData, tfTransformInput.bBox, colorTransformer);
openvdb::tools::foreach(tfTransformInput.colorGrid->beginValueOn(), tfColorTransform);
TfOpacityTransformer opacityTransformer(tfTransformInput.volumeData.TfData);
TfTransform<DataType, OpType, TfOpacityTransformer> tfOpacityTransform(tfTransformInput.volumeData, tfTransformInput.bBox, opacityTransformer);
openvdb::tools::foreach(tfTransformInput.opacityGrid->beginValueOn(), tfOpacityTransform);
}
static void SelectTfTransform(const UsdBridgeLogObject& logObj, TfTransformInput& tfTransformInput)
{
// Transform the float data to color data
switch (tfTransformInput.volumeData.DataType)
{
case UsdBridgeType::CHAR:
TfTransformCall<char, float>(tfTransformInput);
break;
case UsdBridgeType::UCHAR:
TfTransformCall<unsigned char, float>(tfTransformInput);
break;
case UsdBridgeType::SHORT:
TfTransformCall<short, float>(tfTransformInput);
break;
case UsdBridgeType::USHORT:
TfTransformCall<unsigned short, float>(tfTransformInput);
break;
case UsdBridgeType::INT:
TfTransformCall<int, double>(tfTransformInput);
break;
case UsdBridgeType::UINT:
TfTransformCall<unsigned int, double>(tfTransformInput);
break;
case UsdBridgeType::LONG:
TfTransformCall<long long, double>(tfTransformInput);
break;
case UsdBridgeType::ULONG:
TfTransformCall<unsigned long long, double>(tfTransformInput);
break;
case UsdBridgeType::FLOAT:
TfTransformCall<float, float>(tfTransformInput);
break;
case UsdBridgeType::DOUBLE:
TfTransformCall<double, double>(tfTransformInput);
break;
default:
{
const char* typeStr = ubutils::UsdBridgeTypeToString(tfTransformInput.volumeData.DataType);
UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "Volume writer preclassified copy does not support source data type: " << typeStr);
break;
}
}
//openvdb::tools::transformValues(valArray->cbeginValueOn(), *colorGrid, transformOp);
}
struct CopyToGridInput
{
const UsdBridgeVolumeData& volumeData;
const openvdb::CoordBBox& bBox;
};
struct DoublePH // placeholder for double type to implicitly convert to float without warnings
{
public:
DoublePH(double val) : v(val) {}
~DoublePH() {}
operator float() const { return static_cast<float>(v); }
protected:
double v;
};
template<typename InDataType, typename OutGridType>
struct GridConvert
{
GridConvert(const UsdBridgeVolumeData& volumeData, const openvdb::CoordBBox& bBox, bool normalize = true)
: VolData(static_cast<const InDataType*>(volumeData.Data))
, Dims(bBox.max() + openvdb::math::Coord(1, 1, 1)) //Bbox is inclusive, dims are exclusive
, BackgroundIdx(volumeData.BackgroundIdx)
{
}
inline void operator()(const typename OutGridType::ValueOnIter& iter) const
{
openvdb::math::Coord coord = iter.getCoord();
assert(coord.x() >= 0 && coord.x() < Dims.x() &&
coord.y() >= 0 && coord.y() < Dims.y() &&
coord.z() >= 0 && coord.z() < Dims.z());
size_t linearIndex = Dims.y() * Dims.x() * coord.z() + Dims.x() * coord.y() + coord.x();
const InDataType* curVal = VolData + linearIndex;
typename OutGridType::ValueType outVal(*curVal);
iter.setValue(outVal);
}
typename OutGridType::ValueType BackgroundValue()
{
if(BackgroundIdx == -1)
{
return typename OutGridType::ValueType(0);
}
const InDataType* backVal = VolData + BackgroundIdx;
typename OutGridType::ValueType outVal(*backVal);
return outVal;
}
const InDataType* VolData;
openvdb::math::Coord Dims;
long long BackgroundIdx;
};
template<typename DataType>
struct NormalizedToGridConvert
{
NormalizedToGridConvert(const UsdBridgeVolumeData& volumeData, const openvdb::CoordBBox& bBox)
: VolData(static_cast<const DataType*>(volumeData.Data))
, Dims(bBox.max() + openvdb::math::Coord(1, 1, 1)) //Bbox is inclusive, dims are exclusive
, MaxValue(static_cast<float>(std::numeric_limits<DataType>::max()))
, MinValue(static_cast<float>(std::numeric_limits<DataType>::min()))
, BackgroundIdx(volumeData.BackgroundIdx)
{
InvRange = 1.0f / (MaxValue - MinValue);
}
inline void operator()(const openvdb::FloatGrid::ValueOnIter& iter) const
{
openvdb::math::Coord coord = iter.getCoord();
assert(coord.x() >= 0 && coord.x() < Dims.x() &&
coord.y() >= 0 && coord.y() < Dims.y() &&
coord.z() >= 0 && coord.z() < Dims.z());
size_t linearIndex = Dims.y() * Dims.x() * coord.z() + Dims.x() * coord.y() + coord.x();
const DataType* curVal = VolData + linearIndex;
iter.setValue(((static_cast<float>(*curVal)) - MinValue) * InvRange);
}
float BackgroundValue()
{
return (BackgroundIdx == -1) ? 0.0f :
(static_cast<float>(*(VolData + BackgroundIdx)) - MinValue) * InvRange;
}
const DataType* VolData;
openvdb::math::Coord Dims;
float MaxValue;
float MinValue;
float InvRange;
long long BackgroundIdx;
};
template<typename InDataType, typename OutGridType>
openvdb::GridBase::Ptr ConvertAndCopyToGridTemplate(const CopyToGridInput& copyInput)
{
GridConvert<InDataType, OutGridType> gridConverter(copyInput.volumeData, copyInput.bBox);
typename OutGridType::Ptr outGrid = OutGridType::create(gridConverter.BackgroundValue());
typename OutGridType::ValueType defaultValue(0);
outGrid->denseFill(copyInput.bBox, defaultValue, true);
openvdb::tools::foreach(outGrid->beginValueOn(), gridConverter);
return outGrid;
}
template<typename DataType>
openvdb::GridBase::Ptr NormalizedCopyToGridTemplate(const CopyToGridInput& copyInput)
{
NormalizedToGridConvert<DataType> gridConverter(copyInput.volumeData, copyInput.bBox);
openvdb::FloatGrid::Ptr floatGrid = openvdb::FloatGrid::create(gridConverter.BackgroundValue());
floatGrid->denseFill(copyInput.bBox, 0.0f, true);
openvdb::tools::foreach(floatGrid->beginValueOn(), gridConverter);
return floatGrid;
}
template<typename DataType, typename GridType>
openvdb::GridBase::Ptr CopyToGridTemplate(const CopyToGridInput& copyInput)
{
const DataType* typedData = static_cast<const DataType*>(copyInput.volumeData.Data);
long long backgroundIdx = copyInput.volumeData.BackgroundIdx;
typename GridType::ValueType backGroundValue( (backgroundIdx == -1) ?
static_cast<DataType>(0) : *(typedData + backgroundIdx)
);
typename GridType::Ptr scalarGrid = GridType::create(backGroundValue);
openvdb::tools::Dense<const DataType, openvdb::tools::LayoutXYZ> valArray(copyInput.bBox, typedData);
openvdb::tools::copyFromDense(valArray, *scalarGrid, (DataType)0); // No tolerance set to clamp values to background value for sparsity.
return scalarGrid;
}
static openvdb::GridBase::Ptr CopyToGrid(const UsdBridgeLogObject& logObj, const CopyToGridInput& copyInput, bool convertDoubleToFloat)
{
openvdb::GridBase::Ptr scalarGrid;
// Transform the float data to color data
switch (copyInput.volumeData.DataType)
{
case UsdBridgeType::CHAR:
scalarGrid = NormalizedCopyToGridTemplate<char>(copyInput);
break;
case UsdBridgeType::UCHAR:
scalarGrid = NormalizedCopyToGridTemplate<unsigned char>(copyInput);
break;
case UsdBridgeType::SHORT:
scalarGrid = NormalizedCopyToGridTemplate<short>(copyInput);
break;
case UsdBridgeType::USHORT:
scalarGrid = NormalizedCopyToGridTemplate<unsigned short>(copyInput);
break;
case UsdBridgeType::INT:
scalarGrid = CopyToGridTemplate<int, openvdb::Int32Grid>(copyInput);
break;
case UsdBridgeType::UINT:
scalarGrid = CopyToGridTemplate<unsigned int, openvdb::Int32Grid>(copyInput);
break;
case UsdBridgeType::LONG:
scalarGrid = CopyToGridTemplate<long long, openvdb::Int64Grid>(copyInput);
break;
case UsdBridgeType::ULONG:
scalarGrid = CopyToGridTemplate<unsigned long long, openvdb::Int64Grid>(copyInput);
break;
case UsdBridgeType::FLOAT:
scalarGrid = CopyToGridTemplate<float, openvdb::FloatGrid>(copyInput);
break;
case UsdBridgeType::DOUBLE:
if(convertDoubleToFloat)
scalarGrid = ConvertAndCopyToGridTemplate<DoublePH, openvdb::FloatGrid>(copyInput);
else
scalarGrid = CopyToGridTemplate<double, openvdb::DoubleGrid>(copyInput);
break;
case UsdBridgeType::FLOAT3:
scalarGrid = CopyToGridTemplate<openvdb::Vec3f, openvdb::Vec3fGrid>(copyInput);
break;
case UsdBridgeType::DOUBLE3:
if(convertDoubleToFloat)
scalarGrid = ConvertAndCopyToGridTemplate<openvdb::Vec3d, openvdb::Vec3fGrid>(copyInput);
else
scalarGrid = CopyToGridTemplate<openvdb::Vec3d, openvdb::Vec3dGrid>(copyInput);
break;
default:
{
const char* typeStr = ubutils::UsdBridgeTypeToString(copyInput.volumeData.DataType);
UsdBridgeLogMacro(logObj, UsdBridgeLogLevel::ERR, "Volume writer source data copy does not support source data type: " << typeStr);
}
break;
}
return scalarGrid;
}
static void CreateGridAndAdd(const UsdBridgeLogObject& logObj, const UsdBridgeVolumeData& volumeData, const openvdb::CoordBBox& bBox, const char* gridName,
openvdb::math::Transform::Ptr linTrans, bool convertDoubleToFloat, openvdb::GridPtrVecPtr grids)
{
CopyToGridInput copyToGridInput = { volumeData, bBox };
openvdb::GridBase::Ptr outGrid = CopyToGrid(logObj, copyToGridInput, convertDoubleToFloat);
if (outGrid)
{
outGrid->setName(gridName);
outGrid->setTransform(linTrans);
// Push density grid into grid container
grids->push_back(outGrid);
}
}
UsdBridgeVolumeWriter::UsdBridgeVolumeWriter()
: Internals(std::make_unique<UsdBridgeVolumeWriterInternals>())
{
}
UsdBridgeVolumeWriter::~UsdBridgeVolumeWriter()
{
}
bool UsdBridgeVolumeWriter::Initialize(const UsdBridgeLogObject& logObj)
{
openvdb::initialize();
this->LogObject = logObj;
return true;
}
void UsdBridgeVolumeWriter::ToVDB(const UsdBridgeVolumeData& volumeData)
{
const char* densityGridName = "density";
const char* colorGridName = "diffuse";
// Keep the grid/tree transform at identity, and set coord bounding box to element dimensions.
// This will correspond to a worldspace size of element dimensions too, with rest of scaling handled outside of openvdb.
const size_t* coordDims = volumeData.NumElements;
size_t maxInt = std::numeric_limits<int>::max();
assert(coordDims[0] <= maxInt && coordDims[1] <= maxInt && coordDims[2] <= maxInt);
// Wrap data in a Dense and copy to color grid
openvdb::CoordBBox bBox(0, 0, 0, int(coordDims[0] - 1), int(coordDims[1] - 1), int(coordDims[2] - 1)); //Fill is inclusive
// Compose volume transformation
openvdb::math::Transform::Ptr linTrans = openvdb::math::Transform::createLinearTransform();
linTrans->preScale(openvdb::Vec3f(volumeData.CellDimensions));
linTrans->postTranslate(openvdb::Vec3f(volumeData.Origin));
// Prepare output grids
openvdb::GridPtrVecPtr grids(new openvdb::GridPtrVec);
if(volumeData.preClassified)
{
OpacityGridOutType::Ptr opacityGrid = OpacityGridOutType::create();
ColorGridOutType::Ptr colorGrid = ColorGridOutType::create();
opacityGrid->denseFill(bBox, 0.0f, true);
colorGrid->denseFill(bBox,
#ifdef FLOAT1_OUTPUT
0.0f,
#else
openvdb::Vec3f(0, 0, 0),
#endif
true);
// Transform the volumedata and output into color grid
TfTransformInput tfTransformInput = { colorGrid, opacityGrid, volumeData, bBox };
SelectTfTransform(this->LogObject, tfTransformInput);
// Set grid names
opacityGrid->setName(densityGridName);
colorGrid->setName(colorGridName);
// Set grid transformation
opacityGrid->setTransform(linTrans);
colorGrid->setTransform(linTrans);
// Push color and opacity grid into grid container
grids->push_back(opacityGrid);
grids->push_back(colorGrid);
}
else
{
CreateGridAndAdd(this->LogObject, volumeData, bBox, densityGridName, linTrans, ConvertDoubleToFloat, grids);
}
// Must write all grids at once
openvdb::io::Stream(Internals->ResetStream()).write(*grids);
}
void UsdBridgeVolumeWriter::GetSerializedVolumeData(const char*& data, size_t& size)
{
data = Internals->GetStreamData();
size = Internals->GetStreamDataSize();
}
#else //USE_OPENVDB
UsdBridgeVolumeWriter::UsdBridgeVolumeWriter()
{
}
UsdBridgeVolumeWriter::~UsdBridgeVolumeWriter()
{
}
bool UsdBridgeVolumeWriter::Initialize(const UsdBridgeLogObject& logObj)
{
return true;
}
void UsdBridgeVolumeWriter::ToVDB(const UsdBridgeVolumeData & volumeData)
{
}
void UsdBridgeVolumeWriter::GetSerializedVolumeData(const char*& data, size_t& size)
{
data = nullptr;
size = 0;
}
#endif //USE_OPENVDB
| 19,286 | C++ | 29.614286 | 155 | 0.722597 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Common/UsdBridgeNumerics.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeNumerics_h
#define UsdBridgeNumerics_h
#include "UsdBridgeMacros.h"
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES
#endif
#include <math.h>
struct UsdUint2
{
using DataType = unsigned int;
DataType Data[2] = { 0, 0 };
};
struct UsdFloat2
{
using DataType = float;
DataType Data[2] = { 1.0, 1.0 };
};
struct UsdFloat3
{
using DataType = float;
DataType Data[3] = { 1.0, 1.0, 1.0 };
};
struct UsdFloat4
{
using DataType = float;
DataType Data[4] = { 1.0, 1.0, 1.0, 1.0 };
};
struct UsdFloatMat4
{
using DataType = float;
DataType Data[16] = {
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1 };
};
struct UsdQuaternion
{
using DataType = float;
DataType Data[4] = {1.0, 0.0, 0.0, 0.0};
};
struct UsdFloatBox1
{
using DataType = float;
DataType Data[2] = { 0.0f, 1.0f };
};
struct UsdFloatBox2
{
using DataType = float;
DataType Data[4] = { 0.0f, 0.0f, 1.0f, 1.0f };
};
namespace usdbridgenumerics
{
template<typename T>
bool isIdentity(const T& val)
{
static T identity;
return !memcmp(val.Data, identity.Data, sizeof(T));
}
inline void DirectionToQuaternionZ(float* dir, float dirLength, float* quat)
{
// Use Z axis of glyph to orient along.
// (dot(|segDir|, zAxis), cross(|segDir|, zAxis)) gives (cos(th), axis*sin(th)),
// but rotation is represented by cos(th/2), axis*sin(th/2), ie. half the amount of rotation.
// So calculate (dot(|halfVec|, zAxis), cross(|halfVec|, zAxis)) instead.
float invDirLength = 1.0f / dirLength;
float halfVec[3] = {
dir[0] * invDirLength,
dir[1] * invDirLength,
dir[2] * invDirLength + 1.0f
};
float halfNorm = sqrtf(halfVec[0] * halfVec[0] + halfVec[1] * halfVec[1] + halfVec[2] * halfVec[2]);
if (halfNorm != 0.0f)
{
float invHalfNorm = 1.0f / halfNorm;
halfVec[0] *= invHalfNorm;
halfVec[1] *= invHalfNorm;
halfVec[2] *= invHalfNorm;
}
// Cross zAxis (0,0,1) with segment direction (new Z axis) to get rotation axis * sin(angle)
float sinAxis[3] = { -halfVec[1], halfVec[0], 0.0f };
// Dot for cos(angle)
float cosAngle = halfVec[2];
if (halfNorm == 0.0f) // In this case there is a 180 degree rotation
{
sinAxis[1] = 1.0f; //sinAxis*sin(pi/2) = (0,1,0)*sin(pi/2) = (0,1,0)
// cosAngle = cos(pi/2) = 0.0f;
}
quat[0] = cosAngle;
quat[1] = sinAxis[0];
quat[2] = sinAxis[1];
quat[3] = sinAxis[2];
}
}
#endif
| 2,578 | C | 20.855932 | 104 | 0.603957 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Common/UsdBridgeUtils_Internal.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeUtils_Internal_h
#define UsdBridgeUtils_Internal_h
#include "UsdBridgeData.h"
#include <cstring>
namespace
{
inline bool strEquals(const char* arg0, const char* arg1)
{
return strcmp(arg0, arg1) == 0;
}
}
#endif | 318 | C | 15.789473 | 59 | 0.72327 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Common/UsdBridgeMacros.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#pragma once
#define USE_USD_GEOM_POINTS
#define OMNIVERSE_CREATE_WORKAROUNDS
//#define CUSTOM_PBR_MDL
#define USE_INDEX_MATERIALS
//#define REPLACE_SCENE_BY_EXTERNAL_STAGE
// To enable output that usdview can digest (just a single float)
//#define USDBRIDGE_VOL_FLOAT1_OUTPUT
#if defined(TIME_CLIP_STAGES) && !defined(VALUE_CLIP_RETIMING)
#define VALUE_CLIP_RETIMING
#endif
#if defined(VALUE_CLIP_RETIMING) && !defined(TIME_BASED_CACHING)
#define TIME_BASED_CACHING
#endif | 554 | C | 24.227272 | 65 | 0.768953 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Common/UsdBridgeData.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeData_h
#define UsdBridgeData_h
#include "UsdBridgeMacros.h"
#include "UsdBridgeNumerics.h"
#include <cstddef>
#include <functional>
#include <stdint.h>
class UsdBridge;
struct UsdBridgePrimCache;
struct UsdBridgeHandle
{
UsdBridgePrimCache* value = nullptr;
};
struct UsdWorldHandle : public UsdBridgeHandle {};
struct UsdInstanceHandle : public UsdBridgeHandle {};
struct UsdGroupHandle : public UsdBridgeHandle {};
struct UsdSurfaceHandle : public UsdBridgeHandle {};
struct UsdGeometryHandle : public UsdBridgeHandle {};
struct UsdVolumeHandle : public UsdBridgeHandle {};
struct UsdSpatialFieldHandle : public UsdBridgeHandle {};
struct UsdSamplerHandle : public UsdBridgeHandle {};
struct UsdShaderHandle : public UsdBridgeHandle {};
struct UsdMaterialHandle : public UsdBridgeHandle {};
struct UsdLightHandle : public UsdBridgeHandle {};
struct UsdCameraHandle : public UsdBridgeHandle {};
enum class UsdBridgeType
{
BOOL = 0,
UCHAR,
UCHAR_SRGB_R,
CHAR,
USHORT,
SHORT,
UINT,
INT,
ULONG,
LONG,
HALF,
FLOAT,
DOUBLE,
UCHAR2,
UCHAR_SRGB_RA,
CHAR2,
USHORT2,
SHORT2,
UINT2,
INT2,
ULONG2,
LONG2,
HALF2,
FLOAT2,
DOUBLE2,
UCHAR3,
UCHAR_SRGB_RGB,
CHAR3,
USHORT3,
SHORT3,
UINT3,
INT3,
ULONG3,
LONG3,
HALF3,
FLOAT3,
DOUBLE3,
UCHAR4,
UCHAR_SRGB_RGBA,
CHAR4,
USHORT4,
SHORT4,
UINT4,
INT4,
ULONG4,
LONG4,
HALF4,
FLOAT4,
DOUBLE4,
INT_PAIR,
INT_PAIR2,
INT_PAIR3,
INT_PAIR4,
FLOAT_PAIR,
FLOAT_PAIR2,
FLOAT_PAIR3,
FLOAT_PAIR4,
DOUBLE_PAIR,
DOUBLE_PAIR2,
DOUBLE_PAIR3,
DOUBLE_PAIR4,
ULONG_PAIR,
ULONG_PAIR2,
ULONG_PAIR3,
ULONG_PAIR4,
FLOAT_MAT2,
FLOAT_MAT3,
FLOAT_MAT4,
FLOAT_MAT2x3,
FLOAT_MAT3x4,
UNDEFINED
};
constexpr int UsdBridgeNumFundamentalTypes = (int)UsdBridgeType::UCHAR2; // Multi-component groups sizes up until 4 should be equal
inline int UsdBridgeTypeNumComponents(UsdBridgeType dataType)
{
int typeIdent = (int)dataType;
if(typeIdent <= (int)UsdBridgeType::DOUBLE4)
return typeIdent / UsdBridgeNumFundamentalTypes;
switch(dataType)
{
case UsdBridgeType::INT_PAIR: return 2;
case UsdBridgeType::INT_PAIR2: return 4;
case UsdBridgeType::INT_PAIR3: return 6;
case UsdBridgeType::INT_PAIR4: return 8;
case UsdBridgeType::FLOAT_PAIR: return 2;
case UsdBridgeType::FLOAT_PAIR2: return 4;
case UsdBridgeType::FLOAT_PAIR3: return 6;
case UsdBridgeType::FLOAT_PAIR4: return 8;
case UsdBridgeType::DOUBLE_PAIR: return 2;
case UsdBridgeType::DOUBLE_PAIR2: return 4;
case UsdBridgeType::DOUBLE_PAIR3: return 6;
case UsdBridgeType::DOUBLE_PAIR4: return 8;
case UsdBridgeType::ULONG_PAIR: return 2;
case UsdBridgeType::ULONG_PAIR2: return 4;
case UsdBridgeType::ULONG_PAIR3: return 6;
case UsdBridgeType::ULONG_PAIR4: return 8;
case UsdBridgeType::FLOAT_MAT2: return 4;
case UsdBridgeType::FLOAT_MAT3: return 9;
case UsdBridgeType::FLOAT_MAT4: return 16;
case UsdBridgeType::FLOAT_MAT2x3: return 6;
case UsdBridgeType::FLOAT_MAT3x4: return 12;
default: return 1;
}
return 1;
}
enum class UsdBridgeGeomType
{
MESH = 0,
INSTANCER,
CURVE,
VOLUME,
NUM_GEOMTYPES
};
enum class UsdBridgeVolumeFieldType
{
DENSITY,
COLOR
};
enum class UsdBridgeLogLevel
{
STATUS,
WARNING,
ERR
};
typedef void(*UsdBridgeLogCallback)(UsdBridgeLogLevel, void*, const char*);
struct UsdBridgeLogObject
{
void* LogUserData;
UsdBridgeLogCallback LogCallback;
};
struct UsdBridgeSettings
{
const char* HostName; // Name of the remote server
const char* OutputPath; // Directory for output (on server if HostName is not empty)
bool CreateNewSession; // Find a new session directory on creation of the bridge, or re-use the last opened one (leave contents intact).
bool BinaryOutput; // Select usda or usd output.
// Output settings
bool EnablePreviewSurfaceShader;
bool EnableMdlShader;
// About to be deprecated
static constexpr bool EnableStTexCoords = false;
};
// Generic attribute definition
struct UsdBridgeAttribute
{
const void* Data = nullptr;
UsdBridgeType DataType = UsdBridgeType::UNDEFINED;
bool PerPrimData = false;
uint32_t EltSize = 0;
const char* Name = nullptr;
};
struct UsdBridgeMeshData
{
static const UsdBridgeGeomType GeomType = UsdBridgeGeomType::MESH;
//Class definitions
enum class DataMemberId : uint32_t
{
NONE = 0,
POINTS = (1 << 0), // Goes together with extent
NORMALS = (1 << 1),
COLORS = (1 << 2),
INDICES = (1 << 3),
ATTRIBUTE0 = (1 << 4),
ATTRIBUTE1 = (1 << 5),
ATTRIBUTE2 = (1 << 6),
ATTRIBUTE3 = (1 << 7),
ALL = (1 << 8) - 1
};
DataMemberId UpdatesToPerform = DataMemberId::ALL;
DataMemberId TimeVarying = DataMemberId::ALL;
bool isEmpty() { return Points == NULL; }
//Mesh data
uint64_t NumPoints = 0;
const void* Points = nullptr;
UsdBridgeType PointsType = UsdBridgeType::UNDEFINED;
const void* Normals = nullptr;
UsdBridgeType NormalsType = UsdBridgeType::UNDEFINED;
bool PerPrimNormals = false;
const void* Colors = nullptr;
UsdBridgeType ColorsType = UsdBridgeType::UNDEFINED;
bool PerPrimColors = false;
const UsdBridgeAttribute* Attributes = nullptr; // Pointer to externally managed attribute array
uint32_t NumAttributes = 0;
const void* Indices = nullptr;
UsdBridgeType IndicesType = UsdBridgeType::UNDEFINED;
uint64_t NumIndices = 0;
int FaceVertexCount = 0;
};
struct UsdBridgeInstancerData
{
static const UsdBridgeGeomType GeomType = UsdBridgeGeomType::INSTANCER;
//Class definitions
enum class DataMemberId : uint32_t
{
NONE = 0,
POINTS = (1 << 0), // Goes together with extent
SHAPEINDICES = (1 << 1),
SCALES = (1 << 2),
ORIENTATIONS = (1 << 3),
LINEARVELOCITIES = (1 << 4),
ANGULARVELOCITIES = (1 << 5),
INSTANCEIDS = (1 << 6),
COLORS = (1 << 7),
INVISIBLEIDS = (1 << 8),
ATTRIBUTE0 = (1 << 9),
ATTRIBUTE1 = (1 << 10),
ATTRIBUTE2 = (1 << 11),
ATTRIBUTE3 = (1 << 12),
ALL = (1 << 13) - 1
};
DataMemberId UpdatesToPerform = DataMemberId::ALL;
DataMemberId TimeVarying = DataMemberId::ALL;
float getUniformScale() const { return Scale.Data[0]; }
bool UseUsdGeomPoints = true; // Shape is sphere and geomPoints is desired
uint64_t NumPoints = 0;
const void* Points = nullptr;
UsdBridgeType PointsType = UsdBridgeType::UNDEFINED;
const int* ShapeIndices = nullptr; //if set, one for every point
const void* Scales = nullptr;// 3-vector scale
UsdBridgeType ScalesType = UsdBridgeType::UNDEFINED;
UsdFloat3 Scale = {1, 1, 1};// In case no scales are given
const void* Orientations = nullptr;
UsdBridgeType OrientationsType = UsdBridgeType::UNDEFINED;
UsdQuaternion Orientation;// In case no orientations are given
const void* Colors = nullptr;
UsdBridgeType ColorsType = UsdBridgeType::UNDEFINED;
static constexpr bool PerPrimColors = false; // For compatibility
const float* LinearVelocities = nullptr;
const float* AngularVelocities = nullptr;
const UsdBridgeAttribute* Attributes = nullptr; // Pointer to externally managed attribute array
uint32_t NumAttributes = 0;
const void* InstanceIds = nullptr;
UsdBridgeType InstanceIdsType = UsdBridgeType::UNDEFINED;
const void* InvisibleIds = nullptr; //Index into points
uint64_t NumInvisibleIds = 0;
UsdBridgeType InvisibleIdsType = UsdBridgeType::UNDEFINED;
};
struct UsdBridgeInstancerRefData
{
enum InstanceShape
{
SHAPE_SPHERE = -1,
SHAPE_CYLINDER = -2,
SHAPE_CONE = -3,
SHAPE_MESH = 0 // Positive values denote meshes (allows for indices into a list of meshes passed along with a list of shapes)
};
InstanceShape DefaultShape = SHAPE_SPHERE;
InstanceShape* Shapes = &DefaultShape;
int NumShapes = 1;
UsdFloatMat4 ShapeTransform;
};
struct UsdBridgeCurveData
{
static const UsdBridgeGeomType GeomType = UsdBridgeGeomType::CURVE;
//Class definitions
enum class DataMemberId : uint32_t
{
NONE = 0,
POINTS = (1 << 0), // Goes together with extent and curvelengths
NORMALS = (1 << 1),
SCALES = (1 << 2),
COLORS = (1 << 3),
CURVELENGTHS = (1 << 4),
ATTRIBUTE0 = (1 << 5),
ATTRIBUTE1 = (1 << 6),
ATTRIBUTE2 = (1 << 7),
ATTRIBUTE3 = (1 << 8),
ALL = (1 << 9) - 1
};
DataMemberId UpdatesToPerform = DataMemberId::ALL;
DataMemberId TimeVarying = DataMemberId::ALL;
bool isEmpty() { return Points == NULL; }
float getUniformScale() const { return UniformScale; }
uint64_t NumPoints = 0;
const void* Points = nullptr;
UsdBridgeType PointsType = UsdBridgeType::UNDEFINED;
const void* Normals = nullptr;
UsdBridgeType NormalsType = UsdBridgeType::UNDEFINED;
bool PerPrimNormals = false;
const void* Colors = nullptr;
UsdBridgeType ColorsType = UsdBridgeType::UNDEFINED;
bool PerPrimColors = false; // One prim would be a full curve
const void* Scales = nullptr; // Used for line width, typically 1-component
UsdBridgeType ScalesType = UsdBridgeType::UNDEFINED;
float UniformScale = 1;// In case no scales are given
const UsdBridgeAttribute* Attributes = nullptr; // Pointer to externally managed attribute array
uint32_t NumAttributes = 0;
const int* CurveLengths = nullptr;
uint64_t NumCurveLengths = 0;
};
struct UsdBridgeTfData
{
const void* TfColors = nullptr;
UsdBridgeType TfColorsType = UsdBridgeType::UNDEFINED;
int TfNumColors = 0;
const void* TfOpacities = nullptr;
UsdBridgeType TfOpacitiesType = UsdBridgeType::UNDEFINED;
int TfNumOpacities = 0;
double TfValueRange[2] = { 0, 1 };
};
struct UsdBridgeVolumeData
{
static constexpr int TFDataStart = 2;
enum class DataMemberId : uint32_t
{
NONE = 0,
DATA = (1 << 1), // Includes the extent - number of elements per dimension
VOL_ALL = (1 << TFDataStart) - 1,
TFCOLORS = (1 << (TFDataStart + 0)),
TFOPACITIES = (1 << (TFDataStart + 1)),
TFVALUERANGE = (1 << (TFDataStart + 2)),
ALL = (1 << (TFDataStart + 3)) - 1
};
#if __cplusplus >= 201703L
static_assert(DataMemberId::TFCOLORS > DataMemberId::VOL_ALL);
#endif
DataMemberId UpdatesToPerform = DataMemberId::ALL;
DataMemberId TimeVarying = DataMemberId::ALL;
bool preClassified = false;
const void* Data = nullptr;
UsdBridgeType DataType = UsdBridgeType::UNDEFINED; // Same timeVarying rule as 'Data'
size_t NumElements[3] = { 0,0,0 }; // Same timeVarying rule as 'Data'
float Origin[3] = { 0,0,0 };
float CellDimensions[3] = { 1,1,1 };
long long BackgroundIdx = -1; // When not -1, denotes the first element in Data which contains a background value
UsdBridgeTfData TfData;
};
struct UsdBridgeMaterialData
{
template<typename ValueType>
struct MaterialInput
{
ValueType Value;
const char* SrcAttrib;
bool Sampler; // Only denote whether a sampler is attached
};
enum class DataMemberId : uint32_t
{
NONE = 0,
DIFFUSE = (1 << 0),
OPACITY = (1 << 1),
EMISSIVECOLOR = (1 << 2),
EMISSIVEINTENSITY = (1 << 3),
ROUGHNESS = (1 << 4),
METALLIC = (1 << 5),
IOR = (1 << 6),
ALL = (1 << 7) - 1
};
DataMemberId TimeVarying = DataMemberId::NONE;
bool IsPbr = true;
enum class AlphaModes : uint32_t
{
NONE,
BLEND,
MASK
};
AlphaModes AlphaMode = AlphaModes::NONE;
float AlphaCutoff = 0.5f;
MaterialInput<UsdFloat3> Diffuse = {{ 1.0f }, nullptr};
MaterialInput<UsdFloat3> Emissive = {{ 1.0f }, nullptr};
MaterialInput<float> Opacity = {1.0f, nullptr};
MaterialInput<float> EmissiveIntensity = {0.0f, nullptr};
MaterialInput<float> Roughness = {0.5f, nullptr};
MaterialInput<float> Metallic = {0.0, nullptr};
MaterialInput<float> Ior = {1.0f, nullptr};
};
template<typename ValueType>
const typename ValueType::DataType* GetValuePtr(const UsdBridgeMaterialData::MaterialInput<ValueType>& input)
{
return input.Value.Data;
}
struct UsdBridgeSamplerData
{
enum class SamplerType : uint32_t
{
SAMPLER_1D = 0,
SAMPLER_2D,
SAMPLER_3D
};
enum class DataMemberId : uint32_t
{
NONE = 0,
DATA = (1 << 0), // Refers to: data(-type), image name/url
WRAPS = (1 << 1),
WRAPT = (1 << 2),
WRAPR = (1 << 3),
ALL = (1 << 4) - 1
};
DataMemberId TimeVarying = DataMemberId::NONE;
enum class WrapMode
{
BLACK = 0,
CLAMP,
REPEAT,
MIRROR
};
SamplerType Type = SamplerType::SAMPLER_1D;
const char* InAttribute = nullptr;
const char* ImageUrl = nullptr;
const char* ImageName = nullptr;
uint64_t ImageDims[3] = {0, 0, 0};
int64_t ImageStride[3] = {0, 0, 0};
int ImageNumComponents = 4;
const void* Data = nullptr;
UsdBridgeType DataType = UsdBridgeType::UNDEFINED;
WrapMode WrapS = WrapMode::BLACK;
WrapMode WrapT = WrapMode::BLACK;
WrapMode WrapR = WrapMode::BLACK;
};
struct UsdSamplerRefData
{
int ImageNumComponents;
double TimeStep;
UsdBridgeMaterialData::DataMemberId DataMemberId; // Material input parameter to connect to
};
struct UsdBridgeCameraData
{
enum class DataMemberId : uint32_t
{
NONE = 0,
VIEW = (1 << 0),
PROJECTION = (1 << 1),
ALL = (1 << 9) - 1
};
DataMemberId TimeVarying = DataMemberId::NONE;
UsdFloat3 Position = {0.0f, 0.0f, 0.0f};
UsdFloat3 Direction = {0.0f, 0.0f, -1.0f};
UsdFloat3 Up = {0.0f, 1.0f, 0.0f};
UsdFloatBox2 ImageRegion = {0.0f, 0.0f, 1.0f, 1.0f};
float Aspect;
float Near;
float Far;
float Fovy;
float Height;
};
template<class TEnum>
struct DefineBitMaskOps
{
static const bool enable = false;
};
template<class TEnum>
struct DefineAddSubOps
{
static const bool enable = false;
};
#define USDBRIDGE_ENABLE_BITMASK_OP(DataType)\
template<>\
struct DefineBitMaskOps<DataType::DataMemberId>\
{\
static const bool enable = true;\
};
#define USDBRIDGE_ENABLE_ADDSUB_OP(DataType)\
template<>\
struct DefineAddSubOps<DataType::DataMemberId>\
{\
static const bool enable = true;\
};
USDBRIDGE_ENABLE_BITMASK_OP(UsdBridgeMeshData);
USDBRIDGE_ENABLE_BITMASK_OP(UsdBridgeInstancerData);
USDBRIDGE_ENABLE_BITMASK_OP(UsdBridgeCurveData);
USDBRIDGE_ENABLE_BITMASK_OP(UsdBridgeVolumeData);
USDBRIDGE_ENABLE_BITMASK_OP(UsdBridgeMaterialData);
USDBRIDGE_ENABLE_BITMASK_OP(UsdBridgeSamplerData);
USDBRIDGE_ENABLE_BITMASK_OP(UsdBridgeCameraData);
USDBRIDGE_ENABLE_ADDSUB_OP(UsdBridgeMeshData);
USDBRIDGE_ENABLE_ADDSUB_OP(UsdBridgeInstancerData);
USDBRIDGE_ENABLE_ADDSUB_OP(UsdBridgeCurveData);
template<class TEnum>
typename std::enable_if<DefineBitMaskOps<TEnum>::enable, TEnum>::type operator |(TEnum lhs, TEnum rhs)
{
using underlying = typename std::underlying_type<TEnum>::type;
return static_cast<TEnum> (
static_cast<underlying>(lhs) |
static_cast<underlying>(rhs)
);
}
template<class TEnum>
typename std::enable_if<DefineBitMaskOps<TEnum>::enable, TEnum>::type operator &(TEnum lhs, TEnum rhs)
{
using underlying = typename std::underlying_type<TEnum>::type;
return static_cast<TEnum> (
static_cast<underlying>(lhs) &
static_cast<underlying>(rhs)
);
}
template<class TEnum>
typename std::enable_if<DefineBitMaskOps<TEnum>::enable, TEnum>::type operator ~(TEnum rhs)
{
using underlying = typename std::underlying_type<TEnum>::type;
return static_cast<TEnum> (~static_cast<underlying>(rhs));
}
template<class TEnum>
typename std::enable_if<DefineAddSubOps<TEnum>::enable, TEnum>::type operator +(TEnum lhs, int rhs)
{
using underlying = typename std::underlying_type<TEnum>::type;
return static_cast<TEnum> ( static_cast<underlying>(lhs) + rhs );
}
template<class T>
class UsdBridgeUpdateEvaluator
{
public:
UsdBridgeUpdateEvaluator(T& data)
: Data(data)
{
}
bool PerformsUpdate(typename T::DataMemberId member) const
{
return ((Data.UpdatesToPerform & member) != T::DataMemberId::NONE);
}
void RemoveUpdate(typename T::DataMemberId member)
{
Data.UpdatesToPerform = (Data.UpdatesToPerform & ~member);
}
void AddUpdate(typename T::DataMemberId member)
{
Data.UpdatesToPerform = (Data.UpdatesToPerform | member);
}
T& Data;
};
#endif
| 16,295 | C | 24.148148 | 150 | 0.694998 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Common/UsdBridgeUtils.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeUtils_h
#define UsdBridgeUtils_h
#include "UsdBridgeData.h"
// USD-independent utils for the UsdBridge
#define UsdBridgeLogMacro(obj, level, message) \
{ std::stringstream logStream; \
logStream << message; \
std::string logString = logStream.str(); \
obj.LogCallback(level, obj.LogUserData, logString.c_str()); }
namespace ubutils
{
const char* UsdBridgeTypeToString(UsdBridgeType type);
UsdBridgeType UsdBridgeTypeFlatten(UsdBridgeType type);
const float* SrgbToLinearTable(); // returns a float[256] array
float SrgbToLinear(float val);
void SrgbToLinear3(float* color); // expects a float[3]
}
#endif | 727 | C | 25.962962 | 65 | 0.742779 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Common/UsdBridgeUtils.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeUtils.h"
#include <cmath>
namespace ubutils
{
const char* UsdBridgeTypeToString(UsdBridgeType type)
{
const char* typeStr = nullptr;
switch(type)
{
case UsdBridgeType::BOOL: typeStr = "BOOL"; break;
case UsdBridgeType::UCHAR: typeStr = "UCHAR"; break;
case UsdBridgeType::UCHAR_SRGB_R: typeStr = "UCHAR_SRGB_R"; break;
case UsdBridgeType::CHAR: typeStr = "CHAR"; break;
case UsdBridgeType::USHORT: typeStr = "USHORT"; break;
case UsdBridgeType::SHORT: typeStr = "SHORT"; break;
case UsdBridgeType::UINT: typeStr = "UINT"; break;
case UsdBridgeType::INT: typeStr = "INT"; break;
case UsdBridgeType::ULONG: typeStr = "ULONG"; break;
case UsdBridgeType::LONG: typeStr = "LONG"; break;
case UsdBridgeType::HALF: typeStr = "HALF"; break;
case UsdBridgeType::FLOAT: typeStr = "FLOAT"; break;
case UsdBridgeType::DOUBLE: typeStr = "DOUBLE"; break;
case UsdBridgeType::UCHAR2: typeStr = "UCHAR2"; break;
case UsdBridgeType::UCHAR_SRGB_RA: typeStr = "UCHAR_SRGB_RA"; break;
case UsdBridgeType::CHAR2: typeStr = "CHAR2"; break;
case UsdBridgeType::USHORT2: typeStr = "USHORT2"; break;
case UsdBridgeType::SHORT2: typeStr = "SHORT2"; break;
case UsdBridgeType::UINT2: typeStr = "UINT2"; break;
case UsdBridgeType::INT2: typeStr = "INT2"; break;
case UsdBridgeType::ULONG2: typeStr = "ULONG2"; break;
case UsdBridgeType::LONG2: typeStr = "LONG2"; break;
case UsdBridgeType::HALF2: typeStr = "HALF2"; break;
case UsdBridgeType::FLOAT2: typeStr = "FLOAT2"; break;
case UsdBridgeType::DOUBLE2: typeStr = "DOUBLE2"; break;
case UsdBridgeType::UCHAR3: typeStr = "UCHAR3"; break;
case UsdBridgeType::UCHAR_SRGB_RGB: typeStr = "UCHAR_SRGB_RGB"; break;
case UsdBridgeType::CHAR3: typeStr = "CHAR3"; break;
case UsdBridgeType::USHORT3: typeStr = "USHORT3"; break;
case UsdBridgeType::SHORT3: typeStr = "SHORT3"; break;
case UsdBridgeType::UINT3: typeStr = "UINT3"; break;
case UsdBridgeType::INT3: typeStr = "INT3"; break;
case UsdBridgeType::ULONG3: typeStr = "ULONG3"; break;
case UsdBridgeType::LONG3: typeStr = "LONG3"; break;
case UsdBridgeType::HALF3: typeStr = "HALF3"; break;
case UsdBridgeType::FLOAT3: typeStr = "FLOAT3"; break;
case UsdBridgeType::DOUBLE3: typeStr = "DOUBLE3"; break;
case UsdBridgeType::UCHAR4: typeStr = "UCHAR4"; break;
case UsdBridgeType::UCHAR_SRGB_RGBA: typeStr = "UCHAR_SRGB_RGBA"; break;
case UsdBridgeType::CHAR4: typeStr = "CHAR4"; break;
case UsdBridgeType::USHORT4: typeStr = "USHORT4"; break;
case UsdBridgeType::SHORT4: typeStr = "SHORT4"; break;
case UsdBridgeType::UINT4: typeStr = "UINT4"; break;
case UsdBridgeType::INT4: typeStr = "INT4"; break;
case UsdBridgeType::ULONG4: typeStr = "ULONG4"; break;
case UsdBridgeType::LONG4: typeStr = "LONG4"; break;
case UsdBridgeType::HALF4: typeStr = "HALF4"; break;
case UsdBridgeType::FLOAT4: typeStr = "FLOAT4"; break;
case UsdBridgeType::DOUBLE4: typeStr = "DOUBLE4"; break;
case UsdBridgeType::INT_PAIR: typeStr = "INT_PAIR"; break;
case UsdBridgeType::INT_PAIR2: typeStr = "INT_PAIR2"; break;
case UsdBridgeType::INT_PAIR3: typeStr = "INT_PAIR3"; break;
case UsdBridgeType::INT_PAIR4: typeStr = "INT_PAIR4"; break;
case UsdBridgeType::FLOAT_PAIR: typeStr = "FLOAT_PAIR"; break;
case UsdBridgeType::FLOAT_PAIR2: typeStr = "FLOAT_PAIR2"; break;
case UsdBridgeType::FLOAT_PAIR3: typeStr = "FLOAT_PAIR3"; break;
case UsdBridgeType::FLOAT_PAIR4: typeStr = "FLOAT_PAIR4"; break;
case UsdBridgeType::DOUBLE_PAIR: typeStr = "DOUBLE_PAIR"; break;
case UsdBridgeType::DOUBLE_PAIR2: typeStr = "DOUBLE_PAIR2"; break;
case UsdBridgeType::DOUBLE_PAIR3: typeStr = "DOUBLE_PAIR3"; break;
case UsdBridgeType::DOUBLE_PAIR4: typeStr = "DOUBLE_PAIR4"; break;
case UsdBridgeType::ULONG_PAIR: typeStr = "ULONG_PAIR"; break;
case UsdBridgeType::ULONG_PAIR2: typeStr = "ULONG_PAIR2"; break;
case UsdBridgeType::ULONG_PAIR3: typeStr = "ULONG_PAIR3"; break;
case UsdBridgeType::ULONG_PAIR4: typeStr = "ULONG_PAIR4"; break;
case UsdBridgeType::FLOAT_MAT2: typeStr = "FLOAT_MAT2"; break;
case UsdBridgeType::FLOAT_MAT3: typeStr = "FLOAT_MAT3"; break;
case UsdBridgeType::FLOAT_MAT4: typeStr = "FLOAT_MAT4"; break;
case UsdBridgeType::FLOAT_MAT2x3: typeStr = "FLOAT_MAT2x3"; break;
case UsdBridgeType::FLOAT_MAT3x4: typeStr = "FLOAT_MAT3x4"; break;
case UsdBridgeType::UNDEFINED: default: typeStr = "UNDEFINED"; break;
}
return typeStr;
}
UsdBridgeType UsdBridgeTypeFlatten(UsdBridgeType type)
{
UsdBridgeType flatType = UsdBridgeType::UNDEFINED;
switch(type)
{
case UsdBridgeType::BOOL:
case UsdBridgeType::UCHAR:
case UsdBridgeType::UCHAR_SRGB_R:
case UsdBridgeType::CHAR:
case UsdBridgeType::USHORT:
case UsdBridgeType::SHORT:
case UsdBridgeType::UINT:
case UsdBridgeType::INT:
case UsdBridgeType::ULONG:
case UsdBridgeType::LONG:
case UsdBridgeType::HALF:
case UsdBridgeType::FLOAT:
case UsdBridgeType::DOUBLE: flatType = type; break;
case UsdBridgeType::UCHAR2: flatType = UsdBridgeType::UCHAR; break;
case UsdBridgeType::UCHAR_SRGB_RA: flatType = UsdBridgeType::UCHAR_SRGB_R; break;
case UsdBridgeType::CHAR2: flatType = UsdBridgeType::CHAR; break;
case UsdBridgeType::USHORT2: flatType = UsdBridgeType::USHORT; break;
case UsdBridgeType::SHORT2: flatType = UsdBridgeType::SHORT; break;
case UsdBridgeType::UINT2: flatType = UsdBridgeType::UINT; break;
case UsdBridgeType::INT2: flatType = UsdBridgeType::INT; break;
case UsdBridgeType::ULONG2: flatType = UsdBridgeType::ULONG; break;
case UsdBridgeType::LONG2: flatType = UsdBridgeType::LONG; break;
case UsdBridgeType::HALF2: flatType = UsdBridgeType::HALF; break;
case UsdBridgeType::FLOAT2: flatType = UsdBridgeType::FLOAT; break;
case UsdBridgeType::DOUBLE2: flatType = UsdBridgeType::DOUBLE; break;
case UsdBridgeType::UCHAR3: flatType = UsdBridgeType::UCHAR; break;
case UsdBridgeType::UCHAR_SRGB_RGB: flatType = UsdBridgeType::UCHAR_SRGB_R; break;
case UsdBridgeType::CHAR3: flatType = UsdBridgeType::CHAR; break;
case UsdBridgeType::USHORT3:flatType = UsdBridgeType::USHORT; break;
case UsdBridgeType::SHORT3: flatType = UsdBridgeType::SHORT; break;
case UsdBridgeType::UINT3: flatType = UsdBridgeType::UINT; break;
case UsdBridgeType::INT3: flatType = UsdBridgeType::INT; break;
case UsdBridgeType::ULONG3: flatType = UsdBridgeType::ULONG; break;
case UsdBridgeType::LONG3: flatType = UsdBridgeType::LONG; break;
case UsdBridgeType::HALF3: flatType = UsdBridgeType::HALF; break;
case UsdBridgeType::FLOAT3: flatType = UsdBridgeType::FLOAT; break;
case UsdBridgeType::DOUBLE3: flatType = UsdBridgeType::DOUBLE; break;
case UsdBridgeType::UCHAR4: flatType = UsdBridgeType::UCHAR; break;
case UsdBridgeType::UCHAR_SRGB_RGBA: flatType = UsdBridgeType::UCHAR_SRGB_R; break;
case UsdBridgeType::CHAR4: flatType = UsdBridgeType::CHAR; break;
case UsdBridgeType::USHORT4: flatType = UsdBridgeType::USHORT; break;
case UsdBridgeType::SHORT4: flatType = UsdBridgeType::SHORT; break;
case UsdBridgeType::UINT4: flatType = UsdBridgeType::UINT; break;
case UsdBridgeType::INT4: flatType = UsdBridgeType::INT; break;
case UsdBridgeType::ULONG4: flatType = UsdBridgeType::ULONG; break;
case UsdBridgeType::LONG4: flatType = UsdBridgeType::LONG; break;
case UsdBridgeType::HALF4: flatType = UsdBridgeType::HALF; break;
case UsdBridgeType::FLOAT4: flatType = UsdBridgeType::FLOAT; break;
case UsdBridgeType::DOUBLE4: flatType = UsdBridgeType::DOUBLE; break;
case UsdBridgeType::INT_PAIR:
case UsdBridgeType::INT_PAIR2:
case UsdBridgeType::INT_PAIR3:
case UsdBridgeType::INT_PAIR4: flatType = UsdBridgeType::INT; break;
case UsdBridgeType::FLOAT_PAIR:
case UsdBridgeType::FLOAT_PAIR2:
case UsdBridgeType::FLOAT_PAIR3:
case UsdBridgeType::FLOAT_PAIR4: flatType = UsdBridgeType::FLOAT; break;
case UsdBridgeType::DOUBLE_PAIR:
case UsdBridgeType::DOUBLE_PAIR2:
case UsdBridgeType::DOUBLE_PAIR3:
case UsdBridgeType::DOUBLE_PAIR4: flatType = UsdBridgeType::DOUBLE; break;
case UsdBridgeType::ULONG_PAIR:
case UsdBridgeType::ULONG_PAIR2:
case UsdBridgeType::ULONG_PAIR3:
case UsdBridgeType::ULONG_PAIR4: flatType = UsdBridgeType::ULONG; break;
case UsdBridgeType::FLOAT_MAT2:
case UsdBridgeType::FLOAT_MAT3:
case UsdBridgeType::FLOAT_MAT4:
case UsdBridgeType::FLOAT_MAT2x3:
case UsdBridgeType::FLOAT_MAT3x4: flatType = UsdBridgeType::FLOAT; break;
case UsdBridgeType::UNDEFINED: default: flatType = UsdBridgeType::UNDEFINED; break;
}
return flatType;
}
const unsigned int SRGBTable[] =
{
0x00000000,0x399f22b4,0x3a1f22b4,0x3a6eb40e,0x3a9f22b4,0x3ac6eb61,0x3aeeb40e,0x3b0b3e5d,
0x3b1f22b4,0x3b33070b,0x3b46eb61,0x3b5b518d,0x3b70f18d,0x3b83e1c6,0x3b8fe616,0x3b9c87fd,
0x3ba9c9b7,0x3bb7ad6f,0x3bc63549,0x3bd56361,0x3be539c1,0x3bf5ba70,0x3c0373b5,0x3c0c6152,
0x3c15a703,0x3c1f45be,0x3c293e6b,0x3c3391f7,0x3c3e4149,0x3c494d43,0x3c54b6c7,0x3c607eb1,
0x3c6ca5df,0x3c792d22,0x3c830aa8,0x3c89af9f,0x3c9085db,0x3c978dc5,0x3c9ec7c2,0x3ca63433,
0x3cadd37d,0x3cb5a601,0x3cbdac20,0x3cc5e639,0x3cce54ab,0x3cd6f7d5,0x3cdfd010,0x3ce8ddb9,
0x3cf2212c,0x3cfb9ac1,0x3d02a569,0x3d0798dc,0x3d0ca7e6,0x3d11d2af,0x3d171963,0x3d1c7c2e,
0x3d21fb3c,0x3d2796b2,0x3d2d4ebb,0x3d332380,0x3d39152b,0x3d3f23e3,0x3d454fd1,0x3d4b991c,
0x3d51ffef,0x3d58846a,0x3d5f26b7,0x3d65e6fe,0x3d6cc564,0x3d73c20f,0x3d7add29,0x3d810b67,
0x3d84b795,0x3d887330,0x3d8c3e4a,0x3d9018f6,0x3d940345,0x3d97fd4a,0x3d9c0716,0x3da020bb,
0x3da44a4b,0x3da883d7,0x3daccd70,0x3db12728,0x3db59112,0x3dba0b3b,0x3dbe95b5,0x3dc33092,
0x3dc7dbe2,0x3dcc97b6,0x3dd1641f,0x3dd6412c,0x3ddb2eef,0x3de02d77,0x3de53cd5,0x3dea5d19,
0x3def8e52,0x3df4d091,0x3dfa23e8,0x3dff8861,0x3e027f07,0x3e054280,0x3e080ea3,0x3e0ae378,
0x3e0dc105,0x3e10a754,0x3e13966b,0x3e168e52,0x3e198f10,0x3e1c98ad,0x3e1fab30,0x3e22c6a3,
0x3e25eb09,0x3e29186c,0x3e2c4ed0,0x3e2f8e41,0x3e32d6c4,0x3e362861,0x3e39831e,0x3e3ce703,
0x3e405416,0x3e43ca5f,0x3e4749e4,0x3e4ad2ae,0x3e4e64c2,0x3e520027,0x3e55a4e6,0x3e595303,
0x3e5d0a8b,0x3e60cb7c,0x3e6495e0,0x3e6869bf,0x3e6c4720,0x3e702e0c,0x3e741e84,0x3e781890,
0x3e7c1c38,0x3e8014c2,0x3e82203c,0x3e84308d,0x3e8645ba,0x3e885fc5,0x3e8a7eb2,0x3e8ca283,
0x3e8ecb3d,0x3e90f8e1,0x3e932b74,0x3e9562f8,0x3e979f71,0x3e99e0e2,0x3e9c274e,0x3e9e72b7,
0x3ea0c322,0x3ea31892,0x3ea57308,0x3ea7d289,0x3eaa3718,0x3eaca0b7,0x3eaf0f69,0x3eb18333,
0x3eb3fc18,0x3eb67a18,0x3eb8fd37,0x3ebb8579,0x3ebe12e1,0x3ec0a571,0x3ec33d2d,0x3ec5da17,
0x3ec87c33,0x3ecb2383,0x3ecdd00b,0x3ed081cd,0x3ed338cc,0x3ed5f50b,0x3ed8b68d,0x3edb7d54,
0x3ede4965,0x3ee11ac1,0x3ee3f16b,0x3ee6cd67,0x3ee9aeb6,0x3eec955d,0x3eef815d,0x3ef272ba,
0x3ef56976,0x3ef86594,0x3efb6717,0x3efe6e02,0x3f00bd2d,0x3f02460e,0x3f03d1a7,0x3f055ff9,
0x3f06f106,0x3f0884cf,0x3f0a1b56,0x3f0bb49b,0x3f0d50a0,0x3f0eef67,0x3f1090f1,0x3f12353e,
0x3f13dc51,0x3f15862b,0x3f1732cd,0x3f18e239,0x3f1a946f,0x3f1c4971,0x3f1e0141,0x3f1fbbdf,
0x3f21794e,0x3f23398e,0x3f24fca0,0x3f26c286,0x3f288b41,0x3f2a56d3,0x3f2c253d,0x3f2df680,
0x3f2fca9e,0x3f31a197,0x3f337b6c,0x3f355820,0x3f3737b3,0x3f391a26,0x3f3aff7c,0x3f3ce7b5,
0x3f3ed2d2,0x3f40c0d4,0x3f42b1be,0x3f44a590,0x3f469c4b,0x3f4895f1,0x3f4a9282,0x3f4c9201,
0x3f4e946e,0x3f5099cb,0x3f52a218,0x3f54ad57,0x3f56bb8a,0x3f58ccb0,0x3f5ae0cd,0x3f5cf7e0,
0x3f5f11ec,0x3f612eee,0x3f634eef,0x3f6571e9,0x3f6797e3,0x3f69c0d6,0x3f6beccd,0x3f6e1bbf,
0x3f704db8,0x3f7282af,0x3f74baae,0x3f76f5ae,0x3f7933b9,0x3f7b74c6,0x3f7db8e0,0x3f800000
};
const float* SrgbToLinearTable()
{
return reinterpret_cast<const float*>(SRGBTable);
}
float SrgbToLinear(float val)
{
if( val < 0.04045f )
val /= 12.92f;
else
val = pow((val + 0.055f)/1.055f,2.4f);
return val;
}
void SrgbToLinear3(float* color)
{
color[0] = SrgbToLinear(color[0]);
color[1] = SrgbToLinear(color[1]);
color[2] = SrgbToLinear(color[2]);
}
} | 12,747 | C++ | 54.91228 | 94 | 0.72519 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Connection/UsdBridgeConnection.cpp | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#include "UsdBridgeConnection.h"
#include <fstream>
#include <sstream>
#include <atomic>
#include <thread>
#include <condition_variable>
#include <algorithm>
#include <cstring>
#ifdef WIN32
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
#include <filesystem>
namespace fs = std::filesystem;
#else
#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#endif
#else
#if (__GNUC__ < 8 || __cplusplus < 201703L)
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#endif
#define UsdBridgeLogMacro(level, message) \
{ std::stringstream logStream; \
logStream << message; \
std::string logString = logStream.str(); \
try \
{ \
UsdBridgeConnection::LogCallback(level, UsdBridgeConnection::LogUserData, logString.c_str()); \
} \
catch (...) {} \
}
#define CONNECT_CATCH(a) \
catch (const std::bad_alloc &) \
{ \
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR,"USDBRIDGECONNECTION BAD ALLOC\n"); \
return a; \
} \
catch (const std::exception &e) \
{ \
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR,"USDBRIDGECONNECTION ERROR: " << e.what()); \
return a; \
} \
catch (...) \
{ \
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR,"USDBRIDGECONNECTION UNKNOWN EXCEPTION\n"); \
return a; \
}
UsdBridgeLogCallback UsdBridgeConnection::LogCallback = nullptr;
void* UsdBridgeConnection::LogUserData = nullptr;
const char* UsdBridgeConnection::GetBaseUrl() const
{
return Settings.WorkingDirectory.c_str();
}
const char* UsdBridgeConnection::GetUrl(const char* path) const
{
TempUrl = Settings.WorkingDirectory + path;
return TempUrl.c_str();
}
bool UsdBridgeConnection::Initialize(const UsdBridgeConnectionSettings& settings,
const UsdBridgeLogObject& logObj)
{
Settings = settings;
UsdBridgeConnection::LogCallback = logObj.LogCallback;
UsdBridgeConnection::LogUserData = logObj.LogUserData;
return true;
}
void UsdBridgeConnection::Shutdown()
{
}
int UsdBridgeConnection::MaxSessionNr() const
{
int sessionNr = 0;
try
{
for (;; ++sessionNr)
{
TempUrl = Settings.WorkingDirectory + "Session_" + std::to_string(sessionNr);
if (!fs::exists(TempUrl))
break;
}
}
CONNECT_CATCH(-1)
return sessionNr - 1;
}
bool UsdBridgeConnection::CreateFolder(const char* dirName, bool isRelative, bool mayExist) const
{
try
{
const char* dirUrl = isRelative ? GetUrl(dirName) : dirName;
if (!mayExist || !fs::exists(dirUrl))
return fs::create_directory(dirUrl);
}
CONNECT_CATCH(false)
return true;
}
bool UsdBridgeConnection::RemoveFolder(const char* dirName, bool isRelative) const
{
bool success = false;
try
{
const char* dirUrl = isRelative ? GetUrl(dirName) : dirName;
if(fs::exists(dirUrl))
success = fs::remove_all(dirUrl);
}
CONNECT_CATCH(false)
return success;
}
bool UsdBridgeConnection::WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary) const
{
try
{
const char* fileUrl = isRelative ? GetUrl(filePath) : filePath;
std::ofstream file(fileUrl, std::ios_base::out
| std::ios_base::trunc
| (binary ? std::ios_base::binary : std::ios_base::out));
if (file.is_open())
{
file.write(data, dataSize);
file.close();
return true;
}
}
CONNECT_CATCH(false)
return false;
}
bool UsdBridgeConnection::RemoveFile(const char* filePath, bool isRelative) const
{
bool success = false;
try
{
const char* fileUrl = isRelative ? GetUrl(filePath) : filePath;
if (fs::exists(fileUrl))
success = fs::remove(fileUrl);
}
CONNECT_CATCH(false)
return success;
}
bool UsdBridgeConnection::ProcessUpdates()
{
return true;
}
class UsdBridgeRemoteConnectionInternals
{
public:
UsdBridgeRemoteConnectionInternals()
: RemoteStream(std::ios::in | std::ios::out)
{}
~UsdBridgeRemoteConnectionInternals()
{}
std::ostream* ResetStream(const char * filePath, bool binary)
{
StreamFilePath = filePath;
StreamIsBinary = binary;
RemoteStream.clear();
return &RemoteStream;
}
// To facility the Omniverse path methods
static constexpr size_t MaxBaseUrlSize = 4096;
char BaseUrlBuffer[MaxBaseUrlSize];
char TempUrlBuffer[MaxBaseUrlSize];
// Status callback handle
uint32_t StatusCallbackHandle = 0;
// Stream
const char* StreamFilePath;
bool StreamIsBinary;
std::stringstream RemoteStream;
};
int UsdBridgeRemoteConnection::NumConnInstances = 0;
int UsdBridgeRemoteConnection::NumInitializedConnInstances = 0;
int UsdBridgeRemoteConnection::ConnectionLogLevel = 0;
UsdBridgeRemoteConnection::UsdBridgeRemoteConnection()
: Internals(new UsdBridgeRemoteConnectionInternals())
{
}
UsdBridgeRemoteConnection::~UsdBridgeRemoteConnection()
{
delete Internals;
}
#ifdef OMNIVERSE_CONNECTION_ENABLE
#include <OmniClient.h>
namespace
{
struct DefaultContext
{
OmniClientResult result = eOmniClientResult_Error;
bool done = false;
};
const char* omniResultToString(OmniClientResult result)
{
const char* msg = nullptr;
switch (result)
{
case eOmniClientResult_Ok: msg = "eOmniClientResult_Ok"; break;
case eOmniClientResult_OkLatest: msg = "eOmniClientResult_OkLatest"; break;
case eOmniClientResult_OkNotYetFound: msg = "eOmniClientResult_OkNotYetFound"; break;
case eOmniClientResult_Error: msg = "eOmniClientResult_Error"; break;
case eOmniClientResult_ErrorConnection: msg = "eOmniClientResult_ErrorConnection"; break;
case eOmniClientResult_ErrorNotSupported: msg = "eOmniClientResult_ErrorNotSupported"; break;
case eOmniClientResult_ErrorAccessDenied: msg = "eOmniClientResult_ErrorAccessDenied"; break;
case eOmniClientResult_ErrorNotFound: msg = "eOmniClientResult_ErrorNotFound"; break;
case eOmniClientResult_ErrorBadVersion: msg = "eOmniClientResult_ErrorBadVersion"; break;
case eOmniClientResult_ErrorAlreadyExists: msg = "eOmniClientResult_ErrorAlreadyExists"; break;
case eOmniClientResult_ErrorAccessLost: msg = "eOmniClientResult_ErrorAccessLost"; break;
default: msg = "Unknown OmniClientResult"; break;
};
return msg;
}
void OmniClientStatusCB(const char* threadName, const char* component, OmniClientLogLevel level, const char* message) OMNICLIENT_NOEXCEPT
{
static std::mutex statusMutex;
std::unique_lock<std::mutex> lk(statusMutex);
// This will return "Verbose", "Info", "Warning", "Error"
//const char* levelString = omniClientGetLogLevelString(level);
char levelChar = omniClientGetLogLevelChar(level);
UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "OmniClient status message: ");
UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "level: " << levelChar << ", thread: " << threadName << ", component: " << component << ", msg: " << message);
}
void OmniClientConnectionStatusCB(void* userData, char const* url, OmniClientConnectionStatus status) OMNICLIENT_NOEXCEPT
{
(void)userData;
static std::mutex statusMutex;
std::unique_lock<std::mutex> lk(statusMutex);
{
std::string urlStr;
if (url) urlStr = url;
switch (status)
{
case eOmniClientConnectionStatus_Connecting: { UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Attempting to connect to " << urlStr); break; }
case eOmniClientConnectionStatus_Connected: { UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Successfully connected to " << urlStr); break; }
case eOmniClientConnectionStatus_ConnectError: { UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Error trying to connect (will attempt reconnection) to " << urlStr); break; }
case eOmniClientConnectionStatus_Disconnected: { UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Disconnected (will attempt reconnection) to " << urlStr); break; }
case Count_eOmniClientConnectionStatus:
default:
break;
}
}
}
OmniClientResult IsValidServerConnection(const char* serverUrl)
{
struct ServerInfoContect : public DefaultContext
{
std::string retVersion;
} context;
omniClientWait(omniClientGetServerInfo(serverUrl, &context,
[](void* userData, OmniClientResult result, OmniClientServerInfo const * info) OMNICLIENT_NOEXCEPT
{
ServerInfoContect& context = *(ServerInfoContect*)(userData);
if (context.result != eOmniClientResult_Ok)
{
context.result = result;
if (result == eOmniClientResult_Ok && info->version)
{
context.retVersion = info->version;
}
context.done = true;
}
})
);
return context.result;
}
void UsdBridgeSetConnectionLogLevel(int logLevel)
{
int clampedLevel = eOmniClientLogLevel_Debug + (logLevel < 0 ? 0 : logLevel);
clampedLevel = (clampedLevel < (int)Count_eOmniClientLogLevel) ? clampedLevel : Count_eOmniClientLogLevel - 1;
omniClientSetLogLevel((OmniClientLogLevel)clampedLevel);
}
}
const char* UsdBridgeRemoteConnection::GetBaseUrl() const
{
return Internals->BaseUrlBuffer;
}
const char* UsdBridgeRemoteConnection::GetUrl(const char* path) const
{
size_t parsedBufSize = Internals->MaxBaseUrlSize;
char* combinedUrl = omniClientCombineUrls(Internals->BaseUrlBuffer, path, Internals->TempUrlBuffer, &parsedBufSize);
return combinedUrl;
}
bool UsdBridgeRemoteConnection::Initialize(const UsdBridgeConnectionSettings& settings,
const UsdBridgeLogObject& logObj)
{
bool initSuccess = UsdBridgeConnection::Initialize(settings, logObj);
if (NumInitializedConnInstances == 0)
{
omniClientSetLogCallback(OmniClientStatusCB);
}
if (NumConnInstances == 0)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Establishing connection - Omniverse Client Initialization -");
initSuccess = omniClientInitialize(kOmniClientVersion);
UsdBridgeSetConnectionLogLevel(ConnectionLogLevel);
}
++NumConnInstances;
if (initSuccess && NumInitializedConnInstances == 0)
{
Internals->StatusCallbackHandle = omniClientRegisterConnectionStatusCallback(nullptr, OmniClientConnectionStatusCB);
}
if (initSuccess)
{
// Check for Url validity for its various components
std::string serverUrl = "omniverse://" + Settings.HostName + "/";
std::string rawUrl = serverUrl + Settings.WorkingDirectory;
OmniClientUrl* brokenUrl = omniClientBreakUrl(rawUrl.c_str());
if (!brokenUrl->scheme)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR, "Illegal Omniverse scheme.");
initSuccess = false;
}
if (!brokenUrl->host || strlen(brokenUrl->host) == 0)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR, "Illegal Omniverse server.");
initSuccess = false;
}
if (!brokenUrl->path || strlen(brokenUrl->path) == 0)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR, "Illegal Omniverse working directory.");
initSuccess = false;
}
char* urlRes = nullptr;
if (initSuccess)
{
size_t parsedBufSize = Internals->MaxBaseUrlSize;
urlRes = omniClientMakeUrl(brokenUrl, Internals->BaseUrlBuffer, &parsedBufSize);
if (!urlRes)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR, "Connection Url invalid, exceeds 4096 characters.");
initSuccess = false;
}
}
if (initSuccess)
{
OmniClientResult result = IsValidServerConnection(serverUrl.c_str());
if (result != eOmniClientResult_Ok)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR, "Server connection cannot be established, errorcode:" << omniResultToString(result));
initSuccess = false;
}
}
if (initSuccess)
{
bool result = this->CheckWritePermissions();
if (!result)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR, "Omniverse user does not have write permissions to selected output directory.");
initSuccess = false;
}
}
if (initSuccess)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Server for connection:" << brokenUrl->host);
if (brokenUrl->port)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Port for connection:" << brokenUrl->port);
}
if (NumInitializedConnInstances == 0)
{
//omniClientPushBaseUrl(urlRes); // Base urls only apply to *normal* omniClient calls, not usd stage creation
}
++NumInitializedConnInstances;
ConnectionInitialized = true;
}
omniClientFreeUrl(brokenUrl);
}
return initSuccess;
}
void UsdBridgeRemoteConnection::Shutdown()
{
if (ConnectionInitialized && --NumInitializedConnInstances == 0)
{
omniClientSetLogCallback(nullptr);
if (Internals->StatusCallbackHandle)
omniClientUnregisterCallback(Internals->StatusCallbackHandle);
omniClientLiveWaitForPendingUpdates();
//omniClientPopBaseUrl(Internals->BaseUrlBuffer);
//omniClientShutdown();
}
}
int UsdBridgeRemoteConnection::MaxSessionNr() const
{
struct SessionListContext : public DefaultContext
{
int sessionNumber = -1;
} context;
const char* baseUrl = this->GetBaseUrl();
omniClientWait(omniClientList(
baseUrl, &context,
[](void* userData, OmniClientResult result, uint32_t numEntries, struct OmniClientListEntry const* entries) OMNICLIENT_NOEXCEPT
{
auto& context = *(SessionListContext*)(userData);
{
if (result == eOmniClientResult_Ok)
{
for (uint32_t i = 0; i < numEntries; i++)
{
const char* relPath = entries[i].relativePath;
if (strncmp("Session_", relPath, 8) == 0)
{
int pathSessionNr = std::atoi(relPath + 8);
context.sessionNumber = std::max(context.sessionNumber, pathSessionNr);
}
}
}
context.done = true;
}
})
);
return context.sessionNumber;
}
bool UsdBridgeRemoteConnection::CreateFolder(const char* dirName, bool isRelative, bool mayExist) const
{
DefaultContext context;
const char* dirUrl = isRelative ? this->GetUrl(dirName) : dirName;
omniClientWait(omniClientCreateFolder(dirUrl, &context,
[](void* userData, OmniClientResult result) OMNICLIENT_NOEXCEPT
{
auto& context = *(DefaultContext*)(userData);
context.result = result;
context.done = true;
})
);
return context.result == eOmniClientResult_Ok || context.result == eOmniClientResult_OkLatest
|| (mayExist && context.result == eOmniClientResult_ErrorAlreadyExists);
}
bool UsdBridgeRemoteConnection::RemoveFolder(const char* dirName, bool isRelative) const
{
DefaultContext context;
const char* dirUrl = isRelative ? this->GetUrl(dirName) : dirName;
omniClientWait(omniClientDelete(dirUrl, &context,
[](void* userData, OmniClientResult result) OMNICLIENT_NOEXCEPT
{
auto& context = *(DefaultContext*)(userData);
context.result = result;
context.done = true;
})
);
return context.result == eOmniClientResult_Ok || context.result == eOmniClientResult_OkLatest;
}
bool UsdBridgeRemoteConnection::WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary) const
{
(void)binary;
UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Copying data to: " << filePath);
DefaultContext context;
const char* fileUrl = isRelative ? this->GetUrl(filePath) : filePath;
OmniClientContent omniContent{ (void*)data, dataSize, nullptr };
omniClientWait(omniClientWriteFile(fileUrl, &omniContent, &context, [](void* userData, OmniClientResult result) OMNICLIENT_NOEXCEPT
{
auto& context = *(DefaultContext*)(userData);
context.result = result;
context.done = true;
})
);
return context.result == eOmniClientResult_Ok || context.result == eOmniClientResult_OkLatest;
}
bool UsdBridgeRemoteConnection::RemoveFile(const char* filePath, bool isRelative) const
{
DefaultContext context;
UsdBridgeLogMacro(UsdBridgeLogLevel::STATUS, "Removing file: " << filePath);
const char* fileUrl = isRelative ? this->GetUrl(filePath) : filePath;
omniClientWait(omniClientDelete(fileUrl, &context, [](void* userData, OmniClientResult result) OMNICLIENT_NOEXCEPT
{
auto& context = *(DefaultContext*)(userData);
context.result = result;
context.done = true;
})
);
return context.result == eOmniClientResult_Ok || context.result == eOmniClientResult_OkLatest;
}
bool UsdBridgeRemoteConnection::ProcessUpdates()
{
omniClientLiveProcess();
return true;
}
bool UsdBridgeRemoteConnection::CheckWritePermissions()
{
bool success = this->CreateFolder("", true, true);
return success;
}
void UsdBridgeRemoteConnection::SetConnectionLogLevel(int logLevel)
{
ConnectionLogLevel = logLevel;
if (NumConnInstances > 0)
{
UsdBridgeSetConnectionLogLevel(logLevel);
}
}
int UsdBridgeRemoteConnection::GetConnectionLogLevelMax()
{
return Count_eOmniClientLogLevel - 1;
}
#else
const char* UsdBridgeRemoteConnection::GetBaseUrl() const
{
return UsdBridgeConnection::GetBaseUrl();
}
const char* UsdBridgeRemoteConnection::GetUrl(const char* path) const
{
return UsdBridgeConnection::GetUrl(path);
}
bool UsdBridgeRemoteConnection::Initialize(const UsdBridgeConnectionSettings& settings,
const UsdBridgeLogObject& logObj)
{
return UsdBridgeConnection::Initialize(settings, logObj);
}
void UsdBridgeRemoteConnection::Shutdown()
{
UsdBridgeConnection::Shutdown();
}
int UsdBridgeRemoteConnection::MaxSessionNr() const
{
return UsdBridgeConnection::MaxSessionNr();
}
bool UsdBridgeRemoteConnection::CreateFolder(const char* dirName, bool isRelative, bool mayExist) const
{
return UsdBridgeConnection::CreateFolder(dirName, isRelative, mayExist);
}
bool UsdBridgeRemoteConnection::RemoveFolder(const char* dirName, bool isRelative) const
{
return UsdBridgeConnection::RemoveFolder(dirName, isRelative);
}
bool UsdBridgeRemoteConnection::WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary) const
{
return UsdBridgeConnection::WriteFile(data, dataSize, filePath, isRelative, binary);
}
bool UsdBridgeRemoteConnection::RemoveFile(const char* filePath, bool isRelative) const
{
return UsdBridgeConnection::RemoveFile(filePath, isRelative);
}
bool UsdBridgeRemoteConnection::ProcessUpdates()
{
UsdBridgeConnection::ProcessUpdates();
return true;
}
bool UsdBridgeRemoteConnection::CheckWritePermissions()
{
return true;
}
void UsdBridgeRemoteConnection::SetConnectionLogLevel(int logLevel)
{
}
int UsdBridgeRemoteConnection::GetConnectionLogLevelMax()
{
return 0;
}
#endif //OMNIVERSE_CONNECTION_ENABLE
UsdBridgeLocalConnection::UsdBridgeLocalConnection()
{
}
UsdBridgeLocalConnection::~UsdBridgeLocalConnection()
{
}
const char* UsdBridgeLocalConnection::GetBaseUrl() const
{
return UsdBridgeConnection::GetBaseUrl();
}
const char* UsdBridgeLocalConnection::GetUrl(const char* path) const
{
return UsdBridgeConnection::GetUrl(path);
}
bool UsdBridgeLocalConnection::Initialize(const UsdBridgeConnectionSettings& settings, const UsdBridgeLogObject& logObj)
{
bool initSuccess = UsdBridgeConnection::Initialize(settings, logObj);
if (initSuccess)
{
if (settings.WorkingDirectory.length() == 0)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR, "Local Output Directory not set, cannot initialize output.");
return false;
}
bool workingDirExists = fs::exists(settings.WorkingDirectory);
if (!workingDirExists)
workingDirExists = fs::create_directory(settings.WorkingDirectory);
if (!workingDirExists)
{
UsdBridgeLogMacro(UsdBridgeLogLevel::ERR, "Cannot create Local Output Directory, are permissions set correctly?");
return false;
}
else
{
return true;
}
}
return initSuccess;
}
void UsdBridgeLocalConnection::Shutdown()
{
UsdBridgeConnection::Shutdown();
}
int UsdBridgeLocalConnection::MaxSessionNr() const
{
return UsdBridgeConnection::MaxSessionNr();
}
bool UsdBridgeLocalConnection::CreateFolder(const char* dirName, bool isRelative, bool mayExist) const
{
return UsdBridgeConnection::CreateFolder(dirName, isRelative, mayExist);
}
bool UsdBridgeLocalConnection::RemoveFolder(const char* dirName, bool isRelative) const
{
return UsdBridgeConnection::RemoveFolder(dirName, isRelative);
}
bool UsdBridgeLocalConnection::WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary) const
{
return UsdBridgeConnection::WriteFile(data, dataSize, filePath, isRelative, binary);
}
bool UsdBridgeLocalConnection::RemoveFile(const char* filePath, bool isRelative) const
{
return UsdBridgeConnection::RemoveFile(filePath, isRelative);
}
bool UsdBridgeLocalConnection::ProcessUpdates()
{
UsdBridgeConnection::ProcessUpdates();
return true;
}
UsdBridgeVoidConnection::UsdBridgeVoidConnection()
{
}
UsdBridgeVoidConnection::~UsdBridgeVoidConnection()
{
}
const char* UsdBridgeVoidConnection::GetBaseUrl() const
{
return UsdBridgeConnection::GetBaseUrl();
}
const char* UsdBridgeVoidConnection::GetUrl(const char* path) const
{
return UsdBridgeConnection::GetUrl(path);
}
bool UsdBridgeVoidConnection::Initialize(const UsdBridgeConnectionSettings& settings, const UsdBridgeLogObject& logObj)
{
bool initialized = UsdBridgeConnection::Initialize(settings, logObj);
Settings.WorkingDirectory = "./";// Force relative working directory in case of unforeseen usd saves based on GetUrl()
return initialized;
}
void UsdBridgeVoidConnection::Shutdown()
{
UsdBridgeConnection::Shutdown();
}
int UsdBridgeVoidConnection::MaxSessionNr() const
{
return -1;
}
bool UsdBridgeVoidConnection::CreateFolder(const char* dirName, bool isRelative, bool mayExist) const
{
return true;
}
bool UsdBridgeVoidConnection::RemoveFolder(const char* dirName, bool isRelative) const
{
return true;
}
bool UsdBridgeVoidConnection::WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary) const
{
return true;
}
bool UsdBridgeVoidConnection::RemoveFile(const char* filePath, bool isRelative) const
{
return true;
}
bool UsdBridgeVoidConnection::ProcessUpdates()
{
return true;
} | 23,255 | C++ | 28.033708 | 178 | 0.697613 |
NVIDIA-Omniverse/AnariUsdDevice/UsdBridge/Connection/UsdBridgeConnection.h | // Copyright 2020 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#ifndef UsdBridgeConnection_h
#define UsdBridgeConnection_h
#include "UsdBridgeData.h"
#include <string>
class UsdBridgeRemoteConnectionInternals;
struct UsdBridgeConnectionSettings
{
std::string HostName;
std::string WorkingDirectory;
};
class UsdBridgeConnection
{
public:
UsdBridgeConnection() {}
virtual ~UsdBridgeConnection() {};
virtual const char* GetBaseUrl() const = 0;
virtual const char* GetUrl(const char* path) const = 0;
virtual bool Initialize(const UsdBridgeConnectionSettings& settings,
const UsdBridgeLogObject& logObj) = 0;
virtual void Shutdown() = 0;
virtual int MaxSessionNr() const = 0;
virtual bool CreateFolder(const char* dirName, bool isRelative, bool mayExist) const = 0;
virtual bool RemoveFolder(const char* dirName, bool isRelative) const = 0;
virtual bool WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary = true) const = 0;
virtual bool RemoveFile(const char* filePath, bool isRelative) const = 0;
virtual bool ProcessUpdates() = 0;
static UsdBridgeLogCallback LogCallback;
static void* LogUserData;
UsdBridgeConnectionSettings Settings;
protected:
mutable std::string TempUrl;
};
class UsdBridgeLocalConnection : public UsdBridgeConnection
{
public:
UsdBridgeLocalConnection();
~UsdBridgeLocalConnection() override;
const char* GetBaseUrl() const override;
const char* GetUrl(const char* path) const override;
bool Initialize(const UsdBridgeConnectionSettings& settings,
const UsdBridgeLogObject& logObj) override;
void Shutdown() override;
int MaxSessionNr() const override;
bool CreateFolder(const char* dirName, bool isRelative, bool mayExist) const override;
bool RemoveFolder(const char* dirName, bool isRelative) const override;
bool WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary = true) const override;
bool RemoveFile(const char* filePath, bool isRelative) const override;
bool ProcessUpdates() override;
protected:
};
class UsdBridgeRemoteConnection : public UsdBridgeConnection
{
public:
UsdBridgeRemoteConnection();
~UsdBridgeRemoteConnection() override;
const char* GetBaseUrl() const override;
const char* GetUrl(const char* path) const override;
bool Initialize(const UsdBridgeConnectionSettings& settings,
const UsdBridgeLogObject& logObj) override;
void Shutdown() override;
int MaxSessionNr() const override;
bool CreateFolder(const char* dirName, bool isRelative, bool mayExist) const override;
bool RemoveFolder(const char* dirName, bool isRelative) const override;
bool WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary = true) const override;
bool RemoveFile(const char* filePath, bool isRelative) const override;
bool ProcessUpdates() override;
static void SetConnectionLogLevel(int logLevel);
static int GetConnectionLogLevelMax();
static int NumConnInstances;
static int NumInitializedConnInstances;
protected:
bool CheckWritePermissions();
UsdBridgeRemoteConnectionInternals* Internals;
bool ConnectionInitialized = false;
static int ConnectionLogLevel;
};
class UsdBridgeVoidConnection : public UsdBridgeConnection
{
public:
UsdBridgeVoidConnection();
~UsdBridgeVoidConnection() override;
const char* GetBaseUrl() const override;
const char* GetUrl(const char* path) const override;
bool Initialize(const UsdBridgeConnectionSettings& settings,
const UsdBridgeLogObject& logObj) override;
void Shutdown() override;
int MaxSessionNr() const override;
bool CreateFolder(const char* dirName, bool isRelative, bool mayExist) const override;
bool RemoveFolder(const char* dirName, bool isRelative) const override;
bool WriteFile(const char* data, size_t dataSize, const char* filePath, bool isRelative, bool binary = true) const override;
bool RemoveFile(const char* filePath, bool isRelative) const override;
bool ProcessUpdates() override;
protected:
};
#endif
| 4,118 | C | 28.007042 | 129 | 0.774648 |
NVIDIA-Omniverse/AnariUsdDevice/thirdparty/stb_image/stb_image.c | // Copyright 2021 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
| 132 | C | 21.166663 | 38 | 0.765152 |
NVIDIA-Omniverse/AnariUsdDevice/thirdparty/stb_image/stb_image_write.c | // Copyright 2021 The Khronos Group
// SPDX-License-Identifier: Apache-2.0
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h" | 143 | C | 27.799994 | 38 | 0.776224 |
NVIDIA-Omniverse/AnariUsdDevice/thirdparty/stb_image/stb_image_write.h | /* stb_image_write - v1.15 - public domain - http://nothings.org/stb
writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
no warranty implied; use at your own risk
Before #including,
#define STB_IMAGE_WRITE_IMPLEMENTATION
in the file that you want to have the implementation.
Will probably not work correctly with strict-aliasing optimizations.
ABOUT:
This header file is a library for writing images to C stdio or a callback.
The PNG output is not optimal; it is 20-50% larger than the file
written by a decent optimizing implementation; though providing a custom
zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that.
This library is designed for source code compactness and simplicity,
not optimal image file size or run-time performance.
BUILDING:
You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h.
You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace
malloc,realloc,free.
You can #define STBIW_MEMMOVE() to replace memmove()
You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function
for PNG compression (instead of the builtin one), it must have the following signature:
unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality);
The returned data will be freed with STBIW_FREE() (free() by default),
so it must be heap allocated with STBIW_MALLOC() (malloc() by default),
UNICODE:
If compiling for Windows and you wish to use Unicode filenames, compile
with
#define STBIW_WINDOWS_UTF8
and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert
Windows wchar_t filenames to utf8.
USAGE:
There are five functions, one for each image file format:
int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality);
int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically
There are also five equivalent functions that use an arbitrary write function. You are
expected to open/close your file-equivalent before and after calling these:
int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);
int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);
where the callback is:
void stbi_write_func(void *context, void *data, int size);
You can configure it with these global variables:
int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE
int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression
int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode
You can define STBI_WRITE_NO_STDIO to disable the file variant of these
functions, so the library will not use stdio.h at all. However, this will
also disable HDR writing, because it requires stdio for formatted output.
Each function returns 0 on failure and non-0 on success.
The functions create an image file defined by the parameters. The image
is a rectangle of pixels stored from left-to-right, top-to-bottom.
Each pixel contains 'comp' channels of data stored interleaved with 8-bits
per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
The *data pointer points to the first byte of the top-left-most pixel.
For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
a row of pixels to the first byte of the next row of pixels.
PNG creates output files with the same number of components as the input.
The BMP format expands Y to RGB in the file format and does not
output alpha.
PNG supports writing rectangles of data even when the bytes storing rows of
data are not consecutive in memory (e.g. sub-rectangles of a larger image),
by supplying the stride between the beginning of adjacent rows. The other
formats do not. (Thus you cannot write a native-format BMP through the BMP
writer, both because it is in BGR order and because it may have padding
at the end of the line.)
PNG allows you to set the deflate compression level by setting the global
variable 'stbi_write_png_compression_level' (it defaults to 8).
HDR expects linear float data. Since the format is always 32-bit rgb(e)
data, alpha (if provided) is discarded, and for monochrome data it is
replicated across all three channels.
TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed
data, set the global variable 'stbi_write_tga_with_rle' to 0.
JPEG does ignore alpha channels in input data; quality is between 1 and 100.
Higher quality looks better but results in a bigger image.
JPEG baseline (no JPEG progressive).
CREDITS:
Sean Barrett - PNG/BMP/TGA
Baldur Karlsson - HDR
Jean-Sebastien Guay - TGA monochrome
Tim Kelsey - misc enhancements
Alan Hickman - TGA RLE
Emmanuel Julien - initial file IO callback implementation
Jon Olick - original jo_jpeg.cpp code
Daniel Gibson - integrate JPEG, allow external zlib
Aarni Koskela - allow choosing PNG filter
bugfixes:
github:Chribba
Guillaume Chereau
github:jry2
github:romigrou
Sergio Gonzalez
Jonas Karlsson
Filip Wasil
Thatcher Ulrich
github:poppolopoppo
Patrick Boettcher
github:xeekworx
Cap Petschulat
Simon Rodriguez
Ivan Tikhonov
github:ignotion
Adam Schackart
LICENSE
See end of file for license information.
*/
#ifndef INCLUDE_STB_IMAGE_WRITE_H
#define INCLUDE_STB_IMAGE_WRITE_H
#include <stdlib.h>
// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'
#ifndef STBIWDEF
#ifdef STB_IMAGE_WRITE_STATIC
#define STBIWDEF static
#else
#ifdef __cplusplus
#define STBIWDEF extern "C"
#else
#define STBIWDEF extern
#endif
#endif
#endif
#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations
extern int stbi_write_tga_with_rle;
extern int stbi_write_png_compression_level;
extern int stbi_write_force_png_filter;
#endif
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);
#ifdef STBI_WINDOWS_UTF8
STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
#endif
#endif
typedef void stbi_write_func(void *context, void *data, int size);
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);
STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);
STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
#endif//INCLUDE_STB_IMAGE_WRITE_H
#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
#ifdef _WIN32
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#ifndef _CRT_NONSTDC_NO_DEPRECATE
#define _CRT_NONSTDC_NO_DEPRECATE
#endif
#endif
#ifndef STBI_WRITE_NO_STDIO
#include <stdio.h>
#endif // STBI_WRITE_NO_STDIO
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))
// ok
#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)
// ok
#else
#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)."
#endif
#ifndef STBIW_MALLOC
#define STBIW_MALLOC(sz) malloc(sz)
#define STBIW_REALLOC(p,newsz) realloc(p,newsz)
#define STBIW_FREE(p) free(p)
#endif
#ifndef STBIW_REALLOC_SIZED
#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)
#endif
#ifndef STBIW_MEMMOVE
#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)
#endif
#ifndef STBIW_ASSERT
#include <assert.h>
#define STBIW_ASSERT(x) assert(x)
#endif
#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)
#ifdef STB_IMAGE_WRITE_STATIC
static int stbi_write_png_compression_level = 8;
static int stbi_write_tga_with_rle = 1;
static int stbi_write_force_png_filter = -1;
#else
int stbi_write_png_compression_level = 8;
int stbi_write_tga_with_rle = 1;
int stbi_write_force_png_filter = -1;
#endif
static int stbi__flip_vertically_on_write = 0;
STBIWDEF void stbi_flip_vertically_on_write(int flag)
{
stbi__flip_vertically_on_write = flag;
}
typedef struct
{
stbi_write_func *func;
void *context;
unsigned char buffer[64];
int buf_used;
} stbi__write_context;
// initialize a callback-based context
static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)
{
s->func = c;
s->context = context;
}
#ifndef STBI_WRITE_NO_STDIO
static void stbi__stdio_write(void *context, void *data, int size)
{
fwrite(data,1,size,(FILE*) context);
}
#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
#ifdef __cplusplus
#define STBIW_EXTERN extern "C"
#else
#define STBIW_EXTERN extern
#endif
STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
{
return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
}
#endif
static FILE *stbiw__fopen(char const *filename, char const *mode)
{
FILE *f;
#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
wchar_t wMode[64];
wchar_t wFilename[1024];
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)))
return 0;
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)))
return 0;
#if _MSC_VER >= 1400
if (0 != _wfopen_s(&f, wFilename, wMode))
f = 0;
#else
f = _wfopen(wFilename, wMode);
#endif
#elif defined(_MSC_VER) && _MSC_VER >= 1400
if (0 != fopen_s(&f, filename, mode))
f=0;
#else
f = fopen(filename, mode);
#endif
return f;
}
static int stbi__start_write_file(stbi__write_context *s, const char *filename)
{
FILE *f = stbiw__fopen(filename, "wb");
stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f);
return f != NULL;
}
static void stbi__end_write_file(stbi__write_context *s)
{
fclose((FILE *)s->context);
}
#endif // !STBI_WRITE_NO_STDIO
typedef unsigned int stbiw_uint32;
typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)
{
while (*fmt) {
switch (*fmt++) {
case ' ': break;
case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int));
s->func(s->context,&x,1);
break; }
case '2': { int x = va_arg(v,int);
unsigned char b[2];
b[0] = STBIW_UCHAR(x);
b[1] = STBIW_UCHAR(x>>8);
s->func(s->context,b,2);
break; }
case '4': { stbiw_uint32 x = va_arg(v,int);
unsigned char b[4];
b[0]=STBIW_UCHAR(x);
b[1]=STBIW_UCHAR(x>>8);
b[2]=STBIW_UCHAR(x>>16);
b[3]=STBIW_UCHAR(x>>24);
s->func(s->context,b,4);
break; }
default:
STBIW_ASSERT(0);
return;
}
}
}
static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)
{
va_list v;
va_start(v, fmt);
stbiw__writefv(s, fmt, v);
va_end(v);
}
static void stbiw__write_flush(stbi__write_context *s)
{
if (s->buf_used) {
s->func(s->context, &s->buffer, s->buf_used);
s->buf_used = 0;
}
}
static void stbiw__putc(stbi__write_context *s, unsigned char c)
{
s->func(s->context, &c, 1);
}
static void stbiw__write1(stbi__write_context *s, unsigned char a)
{
if (s->buf_used + 1 > sizeof(s->buffer))
stbiw__write_flush(s);
s->buffer[s->buf_used++] = a;
}
static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)
{
int n;
if (s->buf_used + 3 > sizeof(s->buffer))
stbiw__write_flush(s);
n = s->buf_used;
s->buf_used = n+3;
s->buffer[n+0] = a;
s->buffer[n+1] = b;
s->buffer[n+2] = c;
}
static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
{
unsigned char bg[3] = { 255, 0, 255}, px[3];
int k;
if (write_alpha < 0)
stbiw__write1(s, d[comp - 1]);
switch (comp) {
case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
case 1:
if (expand_mono)
stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
else
stbiw__write1(s, d[0]); // monochrome TGA
break;
case 4:
if (!write_alpha) {
// composite against pink background
for (k = 0; k < 3; ++k)
px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
break;
}
/* FALLTHROUGH */
case 3:
stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
break;
}
if (write_alpha > 0)
stbiw__write1(s, d[comp - 1]);
}
static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)
{
stbiw_uint32 zero = 0;
int i,j, j_end;
if (y <= 0)
return;
if (stbi__flip_vertically_on_write)
vdir *= -1;
if (vdir < 0) {
j_end = -1; j = y-1;
} else {
j_end = y; j = 0;
}
for (; j != j_end; j += vdir) {
for (i=0; i < x; ++i) {
unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);
}
stbiw__write_flush(s);
s->func(s->context, &zero, scanline_pad);
}
}
static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
{
if (y < 0 || x < 0) {
return 0;
} else {
va_list v;
va_start(v, fmt);
stbiw__writefv(s, fmt, v);
va_end(v);
stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono);
return 1;
}
}
static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
{
int pad = (-x*3) & 3;
return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
"11 4 22 4" "4 44 22 444444",
'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header
40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header
}
STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
{
stbi__write_context s = { 0 };
stbi__start_write_callbacks(&s, func, context);
return stbi_write_bmp_core(&s, x, y, comp, data);
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
int r = stbi_write_bmp_core(&s, x, y, comp, data);
stbi__end_write_file(&s);
return r;
} else
return 0;
}
#endif //!STBI_WRITE_NO_STDIO
static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)
{
int has_alpha = (comp == 2 || comp == 4);
int colorbytes = has_alpha ? comp-1 : comp;
int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
if (y < 0 || x < 0)
return 0;
if (!stbi_write_tga_with_rle) {
return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0,
"111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8);
} else {
int i,j,k;
int jend, jdir;
stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8);
if (stbi__flip_vertically_on_write) {
j = 0;
jend = y;
jdir = 1;
} else {
j = y-1;
jend = -1;
jdir = -1;
}
for (; j != jend; j += jdir) {
unsigned char *row = (unsigned char *) data + j * x * comp;
int len;
for (i = 0; i < x; i += len) {
unsigned char *begin = row + i * comp;
int diff = 1;
len = 1;
if (i < x - 1) {
++len;
diff = memcmp(begin, row + (i + 1) * comp, comp);
if (diff) {
const unsigned char *prev = begin;
for (k = i + 2; k < x && len < 128; ++k) {
if (memcmp(prev, row + k * comp, comp)) {
prev += comp;
++len;
} else {
--len;
break;
}
}
} else {
for (k = i + 2; k < x && len < 128; ++k) {
if (!memcmp(begin, row + k * comp, comp)) {
++len;
} else {
break;
}
}
}
}
if (diff) {
unsigned char header = STBIW_UCHAR(len - 1);
stbiw__write1(s, header);
for (k = 0; k < len; ++k) {
stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp);
}
} else {
unsigned char header = STBIW_UCHAR(len - 129);
stbiw__write1(s, header);
stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin);
}
}
}
stbiw__write_flush(s);
}
return 1;
}
STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
{
stbi__write_context s = { 0 };
stbi__start_write_callbacks(&s, func, context);
return stbi_write_tga_core(&s, x, y, comp, (void *) data);
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);
stbi__end_write_file(&s);
return r;
} else
return 0;
}
#endif
// *************************************************************************************************
// Radiance RGBE HDR writer
// by Baldur Karlsson
#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))
static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
{
int exponent;
float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));
if (maxcomp < 1e-32f) {
rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
} else {
float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp;
rgbe[0] = (unsigned char)(linear[0] * normalize);
rgbe[1] = (unsigned char)(linear[1] * normalize);
rgbe[2] = (unsigned char)(linear[2] * normalize);
rgbe[3] = (unsigned char)(exponent + 128);
}
}
static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
{
unsigned char lengthbyte = STBIW_UCHAR(length+128);
STBIW_ASSERT(length+128 <= 255);
s->func(s->context, &lengthbyte, 1);
s->func(s->context, &databyte, 1);
}
static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
{
unsigned char lengthbyte = STBIW_UCHAR(length);
STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
s->func(s->context, &lengthbyte, 1);
s->func(s->context, data, length);
}
static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)
{
unsigned char scanlineheader[4] = { 2, 2, 0, 0 };
unsigned char rgbe[4];
float linear[3];
int x;
scanlineheader[2] = (width&0xff00)>>8;
scanlineheader[3] = (width&0x00ff);
/* skip RLE for images too small or large */
if (width < 8 || width >= 32768) {
for (x=0; x < width; x++) {
switch (ncomp) {
case 4: /* fallthrough */
case 3: linear[2] = scanline[x*ncomp + 2];
linear[1] = scanline[x*ncomp + 1];
linear[0] = scanline[x*ncomp + 0];
break;
default:
linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
break;
}
stbiw__linear_to_rgbe(rgbe, linear);
s->func(s->context, rgbe, 4);
}
} else {
int c,r;
/* encode into scratch buffer */
for (x=0; x < width; x++) {
switch(ncomp) {
case 4: /* fallthrough */
case 3: linear[2] = scanline[x*ncomp + 2];
linear[1] = scanline[x*ncomp + 1];
linear[0] = scanline[x*ncomp + 0];
break;
default:
linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
break;
}
stbiw__linear_to_rgbe(rgbe, linear);
scratch[x + width*0] = rgbe[0];
scratch[x + width*1] = rgbe[1];
scratch[x + width*2] = rgbe[2];
scratch[x + width*3] = rgbe[3];
}
s->func(s->context, scanlineheader, 4);
/* RLE each component separately */
for (c=0; c < 4; c++) {
unsigned char *comp = &scratch[width*c];
x = 0;
while (x < width) {
// find first run
r = x;
while (r+2 < width) {
if (comp[r] == comp[r+1] && comp[r] == comp[r+2])
break;
++r;
}
if (r+2 >= width)
r = width;
// dump up to first run
while (x < r) {
int len = r-x;
if (len > 128) len = 128;
stbiw__write_dump_data(s, len, &comp[x]);
x += len;
}
// if there's a run, output it
if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd
// find next byte after run
while (r < width && comp[r] == comp[x])
++r;
// output run up to r
while (x < r) {
int len = r-x;
if (len > 127) len = 127;
stbiw__write_run_data(s, len, comp[x]);
x += len;
}
}
}
}
}
}
static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
{
if (y <= 0 || x <= 0 || data == NULL)
return 0;
else {
// Each component is stored separately. Allocate scratch space for full output scanline.
unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
int i, len;
char buffer[128];
char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
s->func(s->context, header, sizeof(header)-1);
#ifdef __STDC_WANT_SECURE_LIB__
len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
#else
len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
#endif
s->func(s->context, buffer, len);
for(i=0; i < y; i++)
stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i));
STBIW_FREE(scratch);
return 1;
}
}
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)
{
stbi__write_context s = { 0 };
stbi__start_write_callbacks(&s, func, context);
return stbi_write_hdr_core(&s, x, y, comp, (float *) data);
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
stbi__end_write_file(&s);
return r;
} else
return 0;
}
#endif // STBI_WRITE_NO_STDIO
//////////////////////////////////////////////////////////////////////////////
//
// PNG writer
//
#ifndef STBIW_ZLIB_COMPRESS
// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)
#define stbiw__sbm(a) stbiw__sbraw(a)[0]
#define stbiw__sbn(a) stbiw__sbraw(a)[1]
#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))
#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)
#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))
#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))
#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)
#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
STBIW_ASSERT(p);
if (p) {
if (!*arr) ((int *) p)[1] = 0;
*arr = (void *) ((int *) p + 2);
stbiw__sbm(*arr) = m;
}
return *arr;
}
static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
while (*bitcount >= 8) {
stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
*bitbuffer >>= 8;
*bitcount -= 8;
}
return data;
}
static int stbiw__zlib_bitrev(int code, int codebits)
{
int res=0;
while (codebits--) {
res = (res << 1) | (code & 1);
code >>= 1;
}
return res;
}
static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
{
int i;
for (i=0; i < limit && i < 258; ++i)
if (a[i] != b[i]) break;
return i;
}
static unsigned int stbiw__zhash(unsigned char *data)
{
stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
hash ^= hash << 3;
hash += hash >> 5;
hash ^= hash << 4;
hash += hash >> 17;
hash ^= hash << 25;
hash += hash >> 6;
return hash;
}
#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))
#define stbiw__zlib_add(code,codebits) \
(bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())
#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)
// default huffman tables
#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)
#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)
#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7)
#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8)
#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))
#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))
#define stbiw__ZHASH 16384
#endif // STBIW_ZLIB_COMPRESS
STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
{
#ifdef STBIW_ZLIB_COMPRESS
// user provided a zlib compress implementation, use that
return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
#else // use builtin
static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 };
static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
unsigned int bitbuf=0;
int i,j, bitcount=0;
unsigned char *out = NULL;
unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**));
if (hash_table == NULL)
return NULL;
if (quality < 5) quality = 5;
stbiw__sbpush(out, 0x78); // DEFLATE 32K window
stbiw__sbpush(out, 0x5e); // FLEVEL = 1
stbiw__zlib_add(1,1); // BFINAL = 1
stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman
for (i=0; i < stbiw__ZHASH; ++i)
hash_table[i] = NULL;
i=0;
while (i < data_len-3) {
// hash next 3 bytes of data to be compressed
int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3;
unsigned char *bestloc = 0;
unsigned char **hlist = hash_table[h];
int n = stbiw__sbcount(hlist);
for (j=0; j < n; ++j) {
if (hlist[j]-data > i-32768) { // if entry lies within window
int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i);
if (d >= best) { best=d; bestloc=hlist[j]; }
}
}
// when hash table entry is too long, delete half the entries
if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) {
STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
stbiw__sbn(hash_table[h]) = quality;
}
stbiw__sbpush(hash_table[h],data+i);
if (bestloc) {
// "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1);
hlist = hash_table[h];
n = stbiw__sbcount(hlist);
for (j=0; j < n; ++j) {
if (hlist[j]-data > i-32767) {
int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1);
if (e > best) { // if next match is better, bail on current match
bestloc = NULL;
break;
}
}
}
}
if (bestloc) {
int d = (int) (data+i - bestloc); // distance back
STBIW_ASSERT(d <= 32767 && best <= 258);
for (j=0; best > lengthc[j+1]-1; ++j);
stbiw__zlib_huff(j+257);
if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]);
for (j=0; d > distc[j+1]-1; ++j);
stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5);
if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]);
i += best;
} else {
stbiw__zlib_huffb(data[i]);
++i;
}
}
// write out final bytes
for (;i < data_len; ++i)
stbiw__zlib_huffb(data[i]);
stbiw__zlib_huff(256); // end of block
// pad with 0 bits to byte boundary
while (bitcount)
stbiw__zlib_add(0,1);
for (i=0; i < stbiw__ZHASH; ++i)
(void) stbiw__sbfree(hash_table[i]);
STBIW_FREE(hash_table);
{
// compute adler32 on input
unsigned int s1=1, s2=0;
int blocklen = (int) (data_len % 5552);
j=0;
while (j < data_len) {
for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; }
s1 %= 65521; s2 %= 65521;
j += blocklen;
blocklen = 5552;
}
stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8));
stbiw__sbpush(out, STBIW_UCHAR(s2));
stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8));
stbiw__sbpush(out, STBIW_UCHAR(s1));
}
*out_len = stbiw__sbn(out);
// make returned pointer freeable
STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
return (unsigned char *) stbiw__sbraw(out);
#endif // STBIW_ZLIB_COMPRESS
}
static unsigned int stbiw__crc32(unsigned char *buffer, int len)
{
#ifdef STBIW_CRC32
return STBIW_CRC32(buffer, len);
#else
static unsigned int crc_table[256] =
{
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
unsigned int crc = ~0u;
int i;
for (i=0; i < len; ++i)
crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
return ~crc;
#endif
}
#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)
#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])
static void stbiw__wpcrc(unsigned char **data, int len)
{
unsigned int crc = stbiw__crc32(*data - len - 4, len+4);
stbiw__wp32(*data, crc);
}
static unsigned char stbiw__paeth(int a, int b, int c)
{
int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);
if (pb <= pc) return STBIW_UCHAR(b);
return STBIW_UCHAR(c);
}
// @OPTIMIZE: provide an option that always forces left-predict or paeth predict
static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)
{
static int mapping[] = { 0,1,2,3,4 };
static int firstmap[] = { 0,1,0,5,6 };
int *mymap = (y != 0) ? mapping : firstmap;
int i;
int type = mymap[filter_type];
unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y);
int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes;
if (type==0) {
memcpy(line_buffer, z, width*n);
return;
}
// first loop isn't optimized since it's just one pixel
for (i = 0; i < n; ++i) {
switch (type) {
case 1: line_buffer[i] = z[i]; break;
case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break;
case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break;
case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break;
case 5: line_buffer[i] = z[i]; break;
case 6: line_buffer[i] = z[i]; break;
}
}
switch (type) {
case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break;
case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break;
case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break;
case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break;
case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break;
case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
}
}
STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
{
int force_filter = stbi_write_force_png_filter;
int ctype[5] = { -1, 0, 4, 2, 6 };
unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
unsigned char *out,*o, *filt, *zlib;
signed char *line_buffer;
int j,zlen;
if (stride_bytes == 0)
stride_bytes = x * n;
if (force_filter >= 5) {
force_filter = -1;
}
filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0;
line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; }
for (j=0; j < y; ++j) {
int filter_type;
if (force_filter > -1) {
filter_type = force_filter;
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);
} else { // Estimate the best filter by running through all of them:
int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
for (filter_type = 0; filter_type < 5; filter_type++) {
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);
// Estimate the entropy of the line using this filter; the less, the better.
est = 0;
for (i = 0; i < x*n; ++i) {
est += abs((signed char) line_buffer[i]);
}
if (est < best_filter_val) {
best_filter_val = est;
best_filter = filter_type;
}
}
if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);
filter_type = best_filter;
}
}
// when we get here, filter_type contains the filter type, and line_buffer contains the data
filt[j*(x*n+1)] = (unsigned char) filter_type;
STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);
}
STBIW_FREE(line_buffer);
zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level);
STBIW_FREE(filt);
if (!zlib) return 0;
// each tag requires 12 bytes of overhead
out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12);
if (!out) return 0;
*out_len = 8 + 12+13 + 12+zlen + 12;
o=out;
STBIW_MEMMOVE(o,sig,8); o+= 8;
stbiw__wp32(o, 13); // header length
stbiw__wptag(o, "IHDR");
stbiw__wp32(o, x);
stbiw__wp32(o, y);
*o++ = 8;
*o++ = STBIW_UCHAR(ctype[n]);
*o++ = 0;
*o++ = 0;
*o++ = 0;
stbiw__wpcrc(&o,13);
stbiw__wp32(o, zlen);
stbiw__wptag(o, "IDAT");
STBIW_MEMMOVE(o, zlib, zlen);
o += zlen;
STBIW_FREE(zlib);
stbiw__wpcrc(&o, zlen);
stbiw__wp32(o,0);
stbiw__wptag(o, "IEND");
stbiw__wpcrc(&o,0);
STBIW_ASSERT(o == out + *out_len);
return out;
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
FILE *f;
int len;
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
if (png == NULL) return 0;
f = stbiw__fopen(filename, "wb");
if (!f) { STBIW_FREE(png); return 0; }
fwrite(png, 1, len, f);
fclose(f);
STBIW_FREE(png);
return 1;
}
#endif
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
{
int len;
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
if (png == NULL) return 0;
func(context, png, len);
STBIW_FREE(png);
return 1;
}
/* ***************************************************************************
*
* JPEG writer
*
* This is based on Jon Olick's jo_jpeg.cpp:
* public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html
*/
static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,
24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 };
static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {
int bitBuf = *bitBufP, bitCnt = *bitCntP;
bitCnt += bs[1];
bitBuf |= bs[0] << (24 - bitCnt);
while(bitCnt >= 8) {
unsigned char c = (bitBuf >> 16) & 255;
stbiw__putc(s, c);
if(c == 255) {
stbiw__putc(s, 0);
}
bitBuf <<= 8;
bitCnt -= 8;
}
*bitBufP = bitBuf;
*bitCntP = bitCnt;
}
static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {
float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
float z1, z2, z3, z4, z5, z11, z13;
float tmp0 = d0 + d7;
float tmp7 = d0 - d7;
float tmp1 = d1 + d6;
float tmp6 = d1 - d6;
float tmp2 = d2 + d5;
float tmp5 = d2 - d5;
float tmp3 = d3 + d4;
float tmp4 = d3 - d4;
// Even part
float tmp10 = tmp0 + tmp3; // phase 2
float tmp13 = tmp0 - tmp3;
float tmp11 = tmp1 + tmp2;
float tmp12 = tmp1 - tmp2;
d0 = tmp10 + tmp11; // phase 3
d4 = tmp10 - tmp11;
z1 = (tmp12 + tmp13) * 0.707106781f; // c4
d2 = tmp13 + z1; // phase 5
d6 = tmp13 - z1;
// Odd part
tmp10 = tmp4 + tmp5; // phase 2
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
// The rotator is modified from fig 4-8 to avoid extra negations.
z5 = (tmp10 - tmp12) * 0.382683433f; // c6
z2 = tmp10 * 0.541196100f + z5; // c2-c6
z4 = tmp12 * 1.306562965f + z5; // c2+c6
z3 = tmp11 * 0.707106781f; // c4
z11 = tmp7 + z3; // phase 5
z13 = tmp7 - z3;
*d5p = z13 + z2; // phase 6
*d3p = z13 - z2;
*d1p = z11 + z4;
*d7p = z11 - z4;
*d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6;
}
static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
int tmp1 = val < 0 ? -val : val;
val = val < 0 ? val-1 : val;
bits[1] = 1;
while(tmp1 >>= 1) {
++bits[1];
}
bits[0] = val & ((1<<bits[1])-1);
}
static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };
const unsigned short M16zeroes[2] = { HTAC[0xF0][0], HTAC[0xF0][1] };
int dataOff, i, j, n, diff, end0pos, x, y;
int DU[64];
// DCT rows
for(dataOff=0, n=du_stride*8; dataOff<n; dataOff+=du_stride) {
stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+1], &CDU[dataOff+2], &CDU[dataOff+3], &CDU[dataOff+4], &CDU[dataOff+5], &CDU[dataOff+6], &CDU[dataOff+7]);
}
// DCT columns
for(dataOff=0; dataOff<8; ++dataOff) {
stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+du_stride], &CDU[dataOff+du_stride*2], &CDU[dataOff+du_stride*3], &CDU[dataOff+du_stride*4],
&CDU[dataOff+du_stride*5], &CDU[dataOff+du_stride*6], &CDU[dataOff+du_stride*7]);
}
// Quantize/descale/zigzag the coefficients
for(y = 0, j=0; y < 8; ++y) {
for(x = 0; x < 8; ++x,++j) {
float v;
i = y*du_stride+x;
v = CDU[i]*fdtbl[j];
// DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
// ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
}
}
// Encode DC
diff = DU[0] - DC;
if (diff == 0) {
stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0]);
} else {
unsigned short bits[2];
stbiw__jpg_calcBits(diff, bits);
stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1]]);
stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
}
// Encode ACs
end0pos = 63;
for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {
}
// end0pos = first element in reverse order !=0
if(end0pos == 0) {
stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
return DU[0];
}
for(i = 1; i <= end0pos; ++i) {
int startpos = i;
int nrzeroes;
unsigned short bits[2];
for (; DU[i]==0 && i<=end0pos; ++i) {
}
nrzeroes = i-startpos;
if ( nrzeroes >= 16 ) {
int lng = nrzeroes>>4;
int nrmarker;
for (nrmarker=1; nrmarker <= lng; ++nrmarker)
stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes);
nrzeroes &= 15;
}
stbiw__jpg_calcBits(DU[i], bits);
stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]);
stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
}
if(end0pos != 63) {
stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
}
return DU[0];
}
static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {
// Constants that don't pollute global namespace
static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};
static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d};
static const unsigned char std_ac_luminance_values[] = {
0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,
0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,
0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
};
static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0};
static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77};
static const unsigned char std_ac_chrominance_values[] = {
0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,
0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,
0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,
0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
};
// Huffman tables
static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}};
static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}};
static const unsigned short YAC_HT[256][2] = {
{10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0},
{2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}
};
static const unsigned short UVAC_HT[256][2] = {
{0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
{16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0},
{1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}
};
static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,
37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99};
static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99};
static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f,
1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f };
int row, col, i, k, subsample;
float fdtbl_Y[64], fdtbl_UV[64];
unsigned char YTable[64], UVTable[64];
if(!data || !width || !height || comp > 4 || comp < 1) {
return 0;
}
quality = quality ? quality : 90;
subsample = quality <= 90 ? 1 : 0;
quality = quality < 1 ? 1 : quality > 100 ? 100 : quality;
quality = quality < 50 ? 5000 / quality : 200 - quality * 2;
for(i = 0; i < 64; ++i) {
int uvti, yti = (YQT[i]*quality+50)/100;
YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti);
uvti = (UVQT[i]*quality+50)/100;
UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti);
}
for(row = 0, k = 0; row < 8; ++row) {
for(col = 0; col < 8; ++col, ++k) {
fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
}
}
// Write Headers
{
static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 };
static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };
const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width),
3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };
s->func(s->context, (void*)head0, sizeof(head0));
s->func(s->context, (void*)YTable, sizeof(YTable));
stbiw__putc(s, 1);
s->func(s->context, UVTable, sizeof(UVTable));
s->func(s->context, (void*)head1, sizeof(head1));
s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1);
s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values));
stbiw__putc(s, 0x10); // HTYACinfo
s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1);
s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values));
stbiw__putc(s, 1); // HTUDCinfo
s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1);
s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values));
stbiw__putc(s, 0x11); // HTUACinfo
s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1);
s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values));
s->func(s->context, (void*)head2, sizeof(head2));
}
// Encode 8x8 macroblocks
{
static const unsigned short fillBits[] = {0x7F, 7};
int DCY=0, DCU=0, DCV=0;
int bitBuf=0, bitCnt=0;
// comp == 2 is grey+alpha (alpha is ignored)
int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;
const unsigned char *dataR = (const unsigned char *)data;
const unsigned char *dataG = dataR + ofsG;
const unsigned char *dataB = dataR + ofsB;
int x, y, pos;
if(subsample) {
for(y = 0; y < height; y += 16) {
for(x = 0; x < width; x += 16) {
float Y[256], U[256], V[256];
for(row = y, pos = 0; row < y+16; ++row) {
// row >= height => use last input row
int clamped_row = (row < height) ? row : height - 1;
int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
for(col = x; col < x+16; ++col, ++pos) {
// if col >= width => use pixel from last input column
int p = base_p + ((col < width) ? col : (width-1))*comp;
float r = dataR[p], g = dataG[p], b = dataB[p];
Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
}
}
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
// subsample U,V
{
float subU[64], subV[64];
int yy, xx;
for(yy = 0, pos = 0; yy < 8; ++yy) {
for(xx = 0; xx < 8; ++xx, ++pos) {
int j = yy*32+xx*2;
subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f;
subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f;
}
}
DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
}
}
}
} else {
for(y = 0; y < height; y += 8) {
for(x = 0; x < width; x += 8) {
float Y[64], U[64], V[64];
for(row = y, pos = 0; row < y+8; ++row) {
// row >= height => use last input row
int clamped_row = (row < height) ? row : height - 1;
int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
for(col = x; col < x+8; ++col, ++pos) {
// if col >= width => use pixel from last input column
int p = base_p + ((col < width) ? col : (width-1))*comp;
float r = dataR[p], g = dataG[p], b = dataB[p];
Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
}
}
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT);
DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
}
}
}
// Do the bit alignment of the EOI marker
stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);
}
// EOI
stbiw__putc(s, 0xFF);
stbiw__putc(s, 0xD9);
return 1;
}
STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)
{
stbi__write_context s = { 0 };
stbi__start_write_callbacks(&s, func, context);
return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality);
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
stbi__end_write_file(&s);
return r;
} else
return 0;
}
#endif
#endif // STB_IMAGE_WRITE_IMPLEMENTATION
/* Revision history
1.14 (2020-02-02) updated JPEG writer to downsample chroma channels
1.13
1.12
1.11 (2019-08-11)
1.10 (2019-02-07)
support utf8 filenames in Windows; fix warnings and platform ifdefs
1.09 (2018-02-11)
fix typo in zlib quality API, improve STB_I_W_STATIC in C++
1.08 (2018-01-29)
add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter
1.07 (2017-07-24)
doc fix
1.06 (2017-07-23)
writing JPEG (using Jon Olick's code)
1.05 ???
1.04 (2017-03-03)
monochrome BMP expansion
1.03 ???
1.02 (2016-04-02)
avoid allocating large structures on the stack
1.01 (2016-01-16)
STBIW_REALLOC_SIZED: support allocators with no realloc support
avoid race-condition in crc initialization
minor compile issues
1.00 (2015-09-14)
installable file IO function
0.99 (2015-09-13)
warning fixes; TGA rle support
0.98 (2015-04-08)
added STBIW_MALLOC, STBIW_ASSERT etc
0.97 (2015-01-18)
fixed HDR asserts, rewrote HDR rle logic
0.96 (2015-01-17)
add HDR output
fix monochrome BMP
0.95 (2014-08-17)
add monochrome TGA output
0.94 (2014-05-31)
rename private functions to avoid conflicts with stb_image.h
0.93 (2014-05-27)
warning fixes
0.92 (2010-08-01)
casts to unsigned char to fix warnings
0.91 (2010-07-17)
first public release
0.90 first internal release
*/
/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2017 Sean Barrett
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
*/
| 69,565 | C | 40.138971 | 205 | 0.587364 |
NVIDIA-Omniverse/AnariUsdDevice/thirdparty/stb_image/stb_image_resize.h | /* stb_image_resize - v0.96 - public domain image resizing
by Jorge L Rodriguez (@VinoBS) - 2014
http://github.com/nothings/stb
Written with emphasis on usability, portability, and efficiency. (No
SIMD or threads, so it be easily outperformed by libs that use those.)
Only scaling and translation is supported, no rotations or shears.
Easy API downsamples w/Mitchell filter, upsamples w/cubic interpolation.
COMPILING & LINKING
In one C/C++ file that #includes this file, do this:
#define STB_IMAGE_RESIZE_IMPLEMENTATION
before the #include. That will create the implementation in that file.
QUICKSTART
stbir_resize_uint8( input_pixels , in_w , in_h , 0,
output_pixels, out_w, out_h, 0, num_channels)
stbir_resize_float(...)
stbir_resize_uint8_srgb( input_pixels , in_w , in_h , 0,
output_pixels, out_w, out_h, 0,
num_channels , alpha_chan , 0)
stbir_resize_uint8_srgb_edgemode(
input_pixels , in_w , in_h , 0,
output_pixels, out_w, out_h, 0,
num_channels , alpha_chan , 0, STBIR_EDGE_CLAMP)
// WRAP/REFLECT/ZERO
FULL API
See the "header file" section of the source for API documentation.
ADDITIONAL DOCUMENTATION
SRGB & FLOATING POINT REPRESENTATION
The sRGB functions presume IEEE floating point. If you do not have
IEEE floating point, define STBIR_NON_IEEE_FLOAT. This will use
a slower implementation.
MEMORY ALLOCATION
The resize functions here perform a single memory allocation using
malloc. To control the memory allocation, before the #include that
triggers the implementation, do:
#define STBIR_MALLOC(size,context) ...
#define STBIR_FREE(ptr,context) ...
Each resize function makes exactly one call to malloc/free, so to use
temp memory, store the temp memory in the context and return that.
ASSERT
Define STBIR_ASSERT(boolval) to override assert() and not use assert.h
OPTIMIZATION
Define STBIR_SATURATE_INT to compute clamp values in-range using
integer operations instead of float operations. This may be faster
on some platforms.
DEFAULT FILTERS
For functions which don't provide explicit control over what filters
to use, you can change the compile-time defaults with
#define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_something
#define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_something
See stbir_filter in the header-file section for the list of filters.
NEW FILTERS
A number of 1D filter kernels are used. For a list of
supported filters see the stbir_filter enum. To add a new filter,
write a filter function and add it to stbir__filter_info_table.
PROGRESS
For interactive use with slow resize operations, you can install
a progress-report callback:
#define STBIR_PROGRESS_REPORT(val) some_func(val)
The parameter val is a float which goes from 0 to 1 as progress is made.
For example:
static void my_progress_report(float progress);
#define STBIR_PROGRESS_REPORT(val) my_progress_report(val)
#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include "stb_image_resize.h"
static void my_progress_report(float progress)
{
printf("Progress: %f%%\n", progress*100);
}
MAX CHANNELS
If your image has more than 64 channels, define STBIR_MAX_CHANNELS
to the max you'll have.
ALPHA CHANNEL
Most of the resizing functions provide the ability to control how
the alpha channel of an image is processed. The important things
to know about this:
1. The best mathematically-behaved version of alpha to use is
called "premultiplied alpha", in which the other color channels
have had the alpha value multiplied in. If you use premultiplied
alpha, linear filtering (such as image resampling done by this
library, or performed in texture units on GPUs) does the "right
thing". While premultiplied alpha is standard in the movie CGI
industry, it is still uncommon in the videogame/real-time world.
If you linearly filter non-premultiplied alpha, strange effects
occur. (For example, the 50/50 average of 99% transparent bright green
and 1% transparent black produces 50% transparent dark green when
non-premultiplied, whereas premultiplied it produces 50%
transparent near-black. The former introduces green energy
that doesn't exist in the source image.)
2. Artists should not edit premultiplied-alpha images; artists
want non-premultiplied alpha images. Thus, art tools generally output
non-premultiplied alpha images.
3. You will get best results in most cases by converting images
to premultiplied alpha before processing them mathematically.
4. If you pass the flag STBIR_FLAG_ALPHA_PREMULTIPLIED, the
resizer does not do anything special for the alpha channel;
it is resampled identically to other channels. This produces
the correct results for premultiplied-alpha images, but produces
less-than-ideal results for non-premultiplied-alpha images.
5. If you do not pass the flag STBIR_FLAG_ALPHA_PREMULTIPLIED,
then the resizer weights the contribution of input pixels
based on their alpha values, or, equivalently, it multiplies
the alpha value into the color channels, resamples, then divides
by the resultant alpha value. Input pixels which have alpha=0 do
not contribute at all to output pixels unless _all_ of the input
pixels affecting that output pixel have alpha=0, in which case
the result for that pixel is the same as it would be without
STBIR_FLAG_ALPHA_PREMULTIPLIED. However, this is only true for
input images in integer formats. For input images in float format,
input pixels with alpha=0 have no effect, and output pixels
which have alpha=0 will be 0 in all channels. (For float images,
you can manually achieve the same result by adding a tiny epsilon
value to the alpha channel of every image, and then subtracting
or clamping it at the end.)
6. You can suppress the behavior described in #5 and make
all-0-alpha pixels have 0 in all channels by #defining
STBIR_NO_ALPHA_EPSILON.
7. You can separately control whether the alpha channel is
interpreted as linear or affected by the colorspace. By default
it is linear; you almost never want to apply the colorspace.
(For example, graphics hardware does not apply sRGB conversion
to the alpha channel.)
CONTRIBUTORS
Jorge L Rodriguez: Implementation
Sean Barrett: API design, optimizations
Aras Pranckevicius: bugfix
Nathan Reed: warning fixes
REVISIONS
0.97 (2020-02-02) fixed warning
0.96 (2019-03-04) fixed warnings
0.95 (2017-07-23) fixed warnings
0.94 (2017-03-18) fixed warnings
0.93 (2017-03-03) fixed bug with certain combinations of heights
0.92 (2017-01-02) fix integer overflow on large (>2GB) images
0.91 (2016-04-02) fix warnings; fix handling of subpixel regions
0.90 (2014-09-17) first released version
LICENSE
See end of file for license information.
TODO
Don't decode all of the image data when only processing a partial tile
Don't use full-width decode buffers when only processing a partial tile
When processing wide images, break processing into tiles so data fits in L1 cache
Installable filters?
Resize that respects alpha test coverage
(Reference code: FloatImage::alphaTestCoverage and FloatImage::scaleAlphaToCoverage:
https://code.google.com/p/nvidia-texture-tools/source/browse/trunk/src/nvimage/FloatImage.cpp )
*/
#ifndef STBIR_INCLUDE_STB_IMAGE_RESIZE_H
#define STBIR_INCLUDE_STB_IMAGE_RESIZE_H
#ifdef _MSC_VER
typedef unsigned char stbir_uint8;
typedef unsigned short stbir_uint16;
typedef unsigned int stbir_uint32;
#else
#include <stdint.h>
typedef uint8_t stbir_uint8;
typedef uint16_t stbir_uint16;
typedef uint32_t stbir_uint32;
#endif
#ifndef STBIRDEF
#ifdef STB_IMAGE_RESIZE_STATIC
#define STBIRDEF static
#else
#ifdef __cplusplus
#define STBIRDEF extern "C"
#else
#define STBIRDEF extern
#endif
#endif
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Easy-to-use API:
//
// * "input pixels" points to an array of image data with 'num_channels' channels (e.g. RGB=3, RGBA=4)
// * input_w is input image width (x-axis), input_h is input image height (y-axis)
// * stride is the offset between successive rows of image data in memory, in bytes. you can
// specify 0 to mean packed continuously in memory
// * alpha channel is treated identically to other channels.
// * colorspace is linear or sRGB as specified by function name
// * returned result is 1 for success or 0 in case of an error.
// #define STBIR_ASSERT() to trigger an assert on parameter validation errors.
// * Memory required grows approximately linearly with input and output size, but with
// discontinuities at input_w == output_w and input_h == output_h.
// * These functions use a "default" resampling filter defined at compile time. To change the filter,
// you can change the compile-time defaults by #defining STBIR_DEFAULT_FILTER_UPSAMPLE
// and STBIR_DEFAULT_FILTER_DOWNSAMPLE, or you can use the medium-complexity API.
STBIRDEF int stbir_resize_uint8( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels);
STBIRDEF int stbir_resize_float( const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels);
// The following functions interpret image data as gamma-corrected sRGB.
// Specify STBIR_ALPHA_CHANNEL_NONE if you have no alpha channel,
// or otherwise provide the index of the alpha channel. Flags value
// of 0 will probably do the right thing if you're not sure what
// the flags mean.
#define STBIR_ALPHA_CHANNEL_NONE -1
// Set this flag if your texture has premultiplied alpha. Otherwise, stbir will
// use alpha-weighted resampling (effectively premultiplying, resampling,
// then unpremultiplying).
#define STBIR_FLAG_ALPHA_PREMULTIPLIED (1 << 0)
// The specified alpha channel should be handled as gamma-corrected value even
// when doing sRGB operations.
#define STBIR_FLAG_ALPHA_USES_COLORSPACE (1 << 1)
STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags);
typedef enum
{
STBIR_EDGE_CLAMP = 1,
STBIR_EDGE_REFLECT = 2,
STBIR_EDGE_WRAP = 3,
STBIR_EDGE_ZERO = 4,
} stbir_edge;
// This function adds the ability to specify how requests to sample off the edge of the image are handled.
STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_wrap_mode);
//////////////////////////////////////////////////////////////////////////////
//
// Medium-complexity API
//
// This extends the easy-to-use API as follows:
//
// * Alpha-channel can be processed separately
// * If alpha_channel is not STBIR_ALPHA_CHANNEL_NONE
// * Alpha channel will not be gamma corrected (unless flags&STBIR_FLAG_GAMMA_CORRECT)
// * Filters will be weighted by alpha channel (unless flags&STBIR_FLAG_ALPHA_PREMULTIPLIED)
// * Filter can be selected explicitly
// * uint16 image type
// * sRGB colorspace available for all types
// * context parameter for passing to STBIR_MALLOC
typedef enum
{
STBIR_FILTER_DEFAULT = 0, // use same filter type that easy-to-use API chooses
STBIR_FILTER_BOX = 1, // A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios
STBIR_FILTER_TRIANGLE = 2, // On upsampling, produces same results as bilinear texture filtering
STBIR_FILTER_CUBICBSPLINE = 3, // The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque
STBIR_FILTER_CATMULLROM = 4, // An interpolating cubic spline
STBIR_FILTER_MITCHELL = 5, // Mitchell-Netrevalli filter with B=1/3, C=1/3
} stbir_filter;
typedef enum
{
STBIR_COLORSPACE_LINEAR,
STBIR_COLORSPACE_SRGB,
STBIR_MAX_COLORSPACES,
} stbir_colorspace;
// The following functions are all identical except for the type of the image data
STBIRDEF int stbir_resize_uint8_generic( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
void *alloc_context);
STBIRDEF int stbir_resize_uint16_generic(const stbir_uint16 *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
stbir_uint16 *output_pixels , int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
void *alloc_context);
STBIRDEF int stbir_resize_float_generic( const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
float *output_pixels , int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
void *alloc_context);
//////////////////////////////////////////////////////////////////////////////
//
// Full-complexity API
//
// This extends the medium API as follows:
//
// * uint32 image type
// * not typesafe
// * separate filter types for each axis
// * separate edge modes for each axis
// * can specify scale explicitly for subpixel correctness
// * can specify image source tile using texture coordinates
typedef enum
{
STBIR_TYPE_UINT8 ,
STBIR_TYPE_UINT16,
STBIR_TYPE_UINT32,
STBIR_TYPE_FLOAT ,
STBIR_MAX_TYPES
} stbir_datatype;
STBIRDEF int stbir_resize( const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
stbir_datatype datatype,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
stbir_filter filter_horizontal, stbir_filter filter_vertical,
stbir_colorspace space, void *alloc_context);
STBIRDEF int stbir_resize_subpixel(const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
stbir_datatype datatype,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
stbir_filter filter_horizontal, stbir_filter filter_vertical,
stbir_colorspace space, void *alloc_context,
float x_scale, float y_scale,
float x_offset, float y_offset);
STBIRDEF int stbir_resize_region( const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
stbir_datatype datatype,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
stbir_filter filter_horizontal, stbir_filter filter_vertical,
stbir_colorspace space, void *alloc_context,
float s0, float t0, float s1, float t1);
// (s0, t0) & (s1, t1) are the top-left and bottom right corner (uv addressing style: [0, 1]x[0, 1]) of a region of the input image to use.
//
//
//// end header file /////////////////////////////////////////////////////
#endif // STBIR_INCLUDE_STB_IMAGE_RESIZE_H
#ifdef STB_IMAGE_RESIZE_IMPLEMENTATION
#ifndef STBIR_ASSERT
#include <assert.h>
#define STBIR_ASSERT(x) assert(x)
#endif
// For memset
#include <string.h>
#include <math.h>
#ifndef STBIR_MALLOC
#include <stdlib.h>
// use comma operator to evaluate c, to avoid "unused parameter" warnings
#define STBIR_MALLOC(size,c) ((void)(c), malloc(size))
#define STBIR_FREE(ptr,c) ((void)(c), free(ptr))
#endif
#ifndef _MSC_VER
#ifdef __cplusplus
#define stbir__inline inline
#else
#define stbir__inline
#endif
#else
#define stbir__inline __forceinline
#endif
// should produce compiler error if size is wrong
typedef unsigned char stbir__validate_uint32[sizeof(stbir_uint32) == 4 ? 1 : -1];
#ifdef _MSC_VER
#define STBIR__NOTUSED(v) (void)(v)
#else
#define STBIR__NOTUSED(v) (void)sizeof(v)
#endif
#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))
#ifndef STBIR_DEFAULT_FILTER_UPSAMPLE
#define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_CATMULLROM
#endif
#ifndef STBIR_DEFAULT_FILTER_DOWNSAMPLE
#define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_MITCHELL
#endif
#ifndef STBIR_PROGRESS_REPORT
#define STBIR_PROGRESS_REPORT(float_0_to_1)
#endif
#ifndef STBIR_MAX_CHANNELS
#define STBIR_MAX_CHANNELS 64
#endif
#if STBIR_MAX_CHANNELS > 65536
#error "Too many channels; STBIR_MAX_CHANNELS must be no more than 65536."
// because we store the indices in 16-bit variables
#endif
// This value is added to alpha just before premultiplication to avoid
// zeroing out color values. It is equivalent to 2^-80. If you don't want
// that behavior (it may interfere if you have floating point images with
// very small alpha values) then you can define STBIR_NO_ALPHA_EPSILON to
// disable it.
#ifndef STBIR_ALPHA_EPSILON
#define STBIR_ALPHA_EPSILON ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))
#endif
#ifdef _MSC_VER
#define STBIR__UNUSED_PARAM(v) (void)(v)
#else
#define STBIR__UNUSED_PARAM(v) (void)sizeof(v)
#endif
// must match stbir_datatype
static unsigned char stbir__type_size[] = {
1, // STBIR_TYPE_UINT8
2, // STBIR_TYPE_UINT16
4, // STBIR_TYPE_UINT32
4, // STBIR_TYPE_FLOAT
};
// Kernel function centered at 0
typedef float (stbir__kernel_fn)(float x, float scale);
typedef float (stbir__support_fn)(float scale);
typedef struct
{
stbir__kernel_fn* kernel;
stbir__support_fn* support;
} stbir__filter_info;
// When upsampling, the contributors are which source pixels contribute.
// When downsampling, the contributors are which destination pixels are contributed to.
typedef struct
{
int n0; // First contributing pixel
int n1; // Last contributing pixel
} stbir__contributors;
typedef struct
{
const void* input_data;
int input_w;
int input_h;
int input_stride_bytes;
void* output_data;
int output_w;
int output_h;
int output_stride_bytes;
float s0, t0, s1, t1;
float horizontal_shift; // Units: output pixels
float vertical_shift; // Units: output pixels
float horizontal_scale;
float vertical_scale;
int channels;
int alpha_channel;
stbir_uint32 flags;
stbir_datatype type;
stbir_filter horizontal_filter;
stbir_filter vertical_filter;
stbir_edge edge_horizontal;
stbir_edge edge_vertical;
stbir_colorspace colorspace;
stbir__contributors* horizontal_contributors;
float* horizontal_coefficients;
stbir__contributors* vertical_contributors;
float* vertical_coefficients;
int decode_buffer_pixels;
float* decode_buffer;
float* horizontal_buffer;
// cache these because ceil/floor are inexplicably showing up in profile
int horizontal_coefficient_width;
int vertical_coefficient_width;
int horizontal_filter_pixel_width;
int vertical_filter_pixel_width;
int horizontal_filter_pixel_margin;
int vertical_filter_pixel_margin;
int horizontal_num_contributors;
int vertical_num_contributors;
int ring_buffer_length_bytes; // The length of an individual entry in the ring buffer. The total number of ring buffers is stbir__get_filter_pixel_width(filter)
int ring_buffer_num_entries; // Total number of entries in the ring buffer.
int ring_buffer_first_scanline;
int ring_buffer_last_scanline;
int ring_buffer_begin_index; // first_scanline is at this index in the ring buffer
float* ring_buffer;
float* encode_buffer; // A temporary buffer to store floats so we don't lose precision while we do multiply-adds.
int horizontal_contributors_size;
int horizontal_coefficients_size;
int vertical_contributors_size;
int vertical_coefficients_size;
int decode_buffer_size;
int horizontal_buffer_size;
int ring_buffer_size;
int encode_buffer_size;
} stbir__info;
static const float stbir__max_uint8_as_float = 255.0f;
static const float stbir__max_uint16_as_float = 65535.0f;
static const double stbir__max_uint32_as_float = 4294967295.0;
static stbir__inline int stbir__min(int a, int b)
{
return a < b ? a : b;
}
static stbir__inline float stbir__saturate(float x)
{
if (x < 0)
return 0;
if (x > 1)
return 1;
return x;
}
#ifdef STBIR_SATURATE_INT
static stbir__inline stbir_uint8 stbir__saturate8(int x)
{
if ((unsigned int) x <= 255)
return x;
if (x < 0)
return 0;
return 255;
}
static stbir__inline stbir_uint16 stbir__saturate16(int x)
{
if ((unsigned int) x <= 65535)
return x;
if (x < 0)
return 0;
return 65535;
}
#endif
static float stbir__srgb_uchar_to_linear_float[256] = {
0.000000f, 0.000304f, 0.000607f, 0.000911f, 0.001214f, 0.001518f, 0.001821f, 0.002125f, 0.002428f, 0.002732f, 0.003035f,
0.003347f, 0.003677f, 0.004025f, 0.004391f, 0.004777f, 0.005182f, 0.005605f, 0.006049f, 0.006512f, 0.006995f, 0.007499f,
0.008023f, 0.008568f, 0.009134f, 0.009721f, 0.010330f, 0.010960f, 0.011612f, 0.012286f, 0.012983f, 0.013702f, 0.014444f,
0.015209f, 0.015996f, 0.016807f, 0.017642f, 0.018500f, 0.019382f, 0.020289f, 0.021219f, 0.022174f, 0.023153f, 0.024158f,
0.025187f, 0.026241f, 0.027321f, 0.028426f, 0.029557f, 0.030713f, 0.031896f, 0.033105f, 0.034340f, 0.035601f, 0.036889f,
0.038204f, 0.039546f, 0.040915f, 0.042311f, 0.043735f, 0.045186f, 0.046665f, 0.048172f, 0.049707f, 0.051269f, 0.052861f,
0.054480f, 0.056128f, 0.057805f, 0.059511f, 0.061246f, 0.063010f, 0.064803f, 0.066626f, 0.068478f, 0.070360f, 0.072272f,
0.074214f, 0.076185f, 0.078187f, 0.080220f, 0.082283f, 0.084376f, 0.086500f, 0.088656f, 0.090842f, 0.093059f, 0.095307f,
0.097587f, 0.099899f, 0.102242f, 0.104616f, 0.107023f, 0.109462f, 0.111932f, 0.114435f, 0.116971f, 0.119538f, 0.122139f,
0.124772f, 0.127438f, 0.130136f, 0.132868f, 0.135633f, 0.138432f, 0.141263f, 0.144128f, 0.147027f, 0.149960f, 0.152926f,
0.155926f, 0.158961f, 0.162029f, 0.165132f, 0.168269f, 0.171441f, 0.174647f, 0.177888f, 0.181164f, 0.184475f, 0.187821f,
0.191202f, 0.194618f, 0.198069f, 0.201556f, 0.205079f, 0.208637f, 0.212231f, 0.215861f, 0.219526f, 0.223228f, 0.226966f,
0.230740f, 0.234551f, 0.238398f, 0.242281f, 0.246201f, 0.250158f, 0.254152f, 0.258183f, 0.262251f, 0.266356f, 0.270498f,
0.274677f, 0.278894f, 0.283149f, 0.287441f, 0.291771f, 0.296138f, 0.300544f, 0.304987f, 0.309469f, 0.313989f, 0.318547f,
0.323143f, 0.327778f, 0.332452f, 0.337164f, 0.341914f, 0.346704f, 0.351533f, 0.356400f, 0.361307f, 0.366253f, 0.371238f,
0.376262f, 0.381326f, 0.386430f, 0.391573f, 0.396755f, 0.401978f, 0.407240f, 0.412543f, 0.417885f, 0.423268f, 0.428691f,
0.434154f, 0.439657f, 0.445201f, 0.450786f, 0.456411f, 0.462077f, 0.467784f, 0.473532f, 0.479320f, 0.485150f, 0.491021f,
0.496933f, 0.502887f, 0.508881f, 0.514918f, 0.520996f, 0.527115f, 0.533276f, 0.539480f, 0.545725f, 0.552011f, 0.558340f,
0.564712f, 0.571125f, 0.577581f, 0.584078f, 0.590619f, 0.597202f, 0.603827f, 0.610496f, 0.617207f, 0.623960f, 0.630757f,
0.637597f, 0.644480f, 0.651406f, 0.658375f, 0.665387f, 0.672443f, 0.679543f, 0.686685f, 0.693872f, 0.701102f, 0.708376f,
0.715694f, 0.723055f, 0.730461f, 0.737911f, 0.745404f, 0.752942f, 0.760525f, 0.768151f, 0.775822f, 0.783538f, 0.791298f,
0.799103f, 0.806952f, 0.814847f, 0.822786f, 0.830770f, 0.838799f, 0.846873f, 0.854993f, 0.863157f, 0.871367f, 0.879622f,
0.887923f, 0.896269f, 0.904661f, 0.913099f, 0.921582f, 0.930111f, 0.938686f, 0.947307f, 0.955974f, 0.964686f, 0.973445f,
0.982251f, 0.991102f, 1.0f
};
static float stbir__srgb_to_linear(float f)
{
if (f <= 0.04045f)
return f / 12.92f;
else
return (float)pow((f + 0.055f) / 1.055f, 2.4f);
}
static float stbir__linear_to_srgb(float f)
{
if (f <= 0.0031308f)
return f * 12.92f;
else
return 1.055f * (float)pow(f, 1 / 2.4f) - 0.055f;
}
#ifndef STBIR_NON_IEEE_FLOAT
// From https://gist.github.com/rygorous/2203834
typedef union
{
stbir_uint32 u;
float f;
} stbir__FP32;
static const stbir_uint32 fp32_to_srgb8_tab4[104] = {
0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d,
0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a,
0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033,
0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067,
0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5,
0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2,
0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143,
0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af,
0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240,
0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300,
0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401,
0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559,
0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723,
};
static stbir_uint8 stbir__linear_to_srgb_uchar(float in)
{
static const stbir__FP32 almostone = { 0x3f7fffff }; // 1-eps
static const stbir__FP32 minval = { (127-13) << 23 };
stbir_uint32 tab,bias,scale,t;
stbir__FP32 f;
// Clamp to [2^(-13), 1-eps]; these two values map to 0 and 1, respectively.
// The tests are carefully written so that NaNs map to 0, same as in the reference
// implementation.
if (!(in > minval.f)) // written this way to catch NaNs
in = minval.f;
if (in > almostone.f)
in = almostone.f;
// Do the table lookup and unpack bias, scale
f.f = in;
tab = fp32_to_srgb8_tab4[(f.u - minval.u) >> 20];
bias = (tab >> 16) << 9;
scale = tab & 0xffff;
// Grab next-highest mantissa bits and perform linear interpolation
t = (f.u >> 12) & 0xff;
return (unsigned char) ((bias + scale*t) >> 16);
}
#else
// sRGB transition values, scaled by 1<<28
static int stbir__srgb_offset_to_linear_scaled[256] =
{
0, 40738, 122216, 203693, 285170, 366648, 448125, 529603,
611080, 692557, 774035, 855852, 942009, 1033024, 1128971, 1229926,
1335959, 1447142, 1563542, 1685229, 1812268, 1944725, 2082664, 2226148,
2375238, 2529996, 2690481, 2856753, 3028870, 3206888, 3390865, 3580856,
3776916, 3979100, 4187460, 4402049, 4622919, 4850123, 5083710, 5323731,
5570236, 5823273, 6082892, 6349140, 6622065, 6901714, 7188133, 7481369,
7781466, 8088471, 8402427, 8723380, 9051372, 9386448, 9728650, 10078021,
10434603, 10798439, 11169569, 11548036, 11933879, 12327139, 12727857, 13136073,
13551826, 13975156, 14406100, 14844697, 15290987, 15745007, 16206795, 16676389,
17153826, 17639142, 18132374, 18633560, 19142734, 19659934, 20185196, 20718552,
21260042, 21809696, 22367554, 22933648, 23508010, 24090680, 24681686, 25281066,
25888850, 26505076, 27129772, 27762974, 28404716, 29055026, 29713942, 30381490,
31057708, 31742624, 32436272, 33138682, 33849884, 34569912, 35298800, 36036568,
36783260, 37538896, 38303512, 39077136, 39859796, 40651528, 41452360, 42262316,
43081432, 43909732, 44747252, 45594016, 46450052, 47315392, 48190064, 49074096,
49967516, 50870356, 51782636, 52704392, 53635648, 54576432, 55526772, 56486700,
57456236, 58435408, 59424248, 60422780, 61431036, 62449032, 63476804, 64514376,
65561776, 66619028, 67686160, 68763192, 69850160, 70947088, 72053992, 73170912,
74297864, 75434880, 76581976, 77739184, 78906536, 80084040, 81271736, 82469648,
83677792, 84896192, 86124888, 87363888, 88613232, 89872928, 91143016, 92423512,
93714432, 95015816, 96327688, 97650056, 98982952, 100326408, 101680440, 103045072,
104420320, 105806224, 107202800, 108610064, 110028048, 111456776, 112896264, 114346544,
115807632, 117279552, 118762328, 120255976, 121760536, 123276016, 124802440, 126339832,
127888216, 129447616, 131018048, 132599544, 134192112, 135795792, 137410592, 139036528,
140673648, 142321952, 143981456, 145652208, 147334208, 149027488, 150732064, 152447968,
154175200, 155913792, 157663776, 159425168, 161197984, 162982240, 164777968, 166585184,
168403904, 170234160, 172075968, 173929344, 175794320, 177670896, 179559120, 181458992,
183370528, 185293776, 187228736, 189175424, 191133888, 193104112, 195086128, 197079968,
199085648, 201103184, 203132592, 205173888, 207227120, 209292272, 211369392, 213458480,
215559568, 217672656, 219797792, 221934976, 224084240, 226245600, 228419056, 230604656,
232802400, 235012320, 237234432, 239468736, 241715280, 243974080, 246245120, 248528464,
250824112, 253132064, 255452368, 257785040, 260130080, 262487520, 264857376, 267239664,
};
static stbir_uint8 stbir__linear_to_srgb_uchar(float f)
{
int x = (int) (f * (1 << 28)); // has headroom so you don't need to clamp
int v = 0;
int i;
// Refine the guess with a short binary search.
i = v + 128; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
i = v + 64; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
i = v + 32; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
i = v + 16; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
i = v + 8; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
i = v + 4; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
i = v + 2; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
i = v + 1; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
return (stbir_uint8) v;
}
#endif
static float stbir__filter_trapezoid(float x, float scale)
{
float halfscale = scale / 2;
float t = 0.5f + halfscale;
STBIR_ASSERT(scale <= 1);
x = (float)fabs(x);
if (x >= t)
return 0;
else
{
float r = 0.5f - halfscale;
if (x <= r)
return 1;
else
return (t - x) / scale;
}
}
static float stbir__support_trapezoid(float scale)
{
STBIR_ASSERT(scale <= 1);
return 0.5f + scale / 2;
}
static float stbir__filter_triangle(float x, float s)
{
STBIR__UNUSED_PARAM(s);
x = (float)fabs(x);
if (x <= 1.0f)
return 1 - x;
else
return 0;
}
static float stbir__filter_cubic(float x, float s)
{
STBIR__UNUSED_PARAM(s);
x = (float)fabs(x);
if (x < 1.0f)
return (4 + x*x*(3*x - 6))/6;
else if (x < 2.0f)
return (8 + x*(-12 + x*(6 - x)))/6;
return (0.0f);
}
static float stbir__filter_catmullrom(float x, float s)
{
STBIR__UNUSED_PARAM(s);
x = (float)fabs(x);
if (x < 1.0f)
return 1 - x*x*(2.5f - 1.5f*x);
else if (x < 2.0f)
return 2 - x*(4 + x*(0.5f*x - 2.5f));
return (0.0f);
}
static float stbir__filter_mitchell(float x, float s)
{
STBIR__UNUSED_PARAM(s);
x = (float)fabs(x);
if (x < 1.0f)
return (16 + x*x*(21 * x - 36))/18;
else if (x < 2.0f)
return (32 + x*(-60 + x*(36 - 7*x)))/18;
return (0.0f);
}
static float stbir__support_zero(float s)
{
STBIR__UNUSED_PARAM(s);
return 0;
}
static float stbir__support_one(float s)
{
STBIR__UNUSED_PARAM(s);
return 1;
}
static float stbir__support_two(float s)
{
STBIR__UNUSED_PARAM(s);
return 2;
}
static stbir__filter_info stbir__filter_info_table[] = {
{ NULL, stbir__support_zero },
{ stbir__filter_trapezoid, stbir__support_trapezoid },
{ stbir__filter_triangle, stbir__support_one },
{ stbir__filter_cubic, stbir__support_two },
{ stbir__filter_catmullrom, stbir__support_two },
{ stbir__filter_mitchell, stbir__support_two },
};
stbir__inline static int stbir__use_upsampling(float ratio)
{
return ratio > 1;
}
stbir__inline static int stbir__use_width_upsampling(stbir__info* stbir_info)
{
return stbir__use_upsampling(stbir_info->horizontal_scale);
}
stbir__inline static int stbir__use_height_upsampling(stbir__info* stbir_info)
{
return stbir__use_upsampling(stbir_info->vertical_scale);
}
// This is the maximum number of input samples that can affect an output sample
// with the given filter
static int stbir__get_filter_pixel_width(stbir_filter filter, float scale)
{
STBIR_ASSERT(filter != 0);
STBIR_ASSERT(filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));
if (stbir__use_upsampling(scale))
return (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2);
else
return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2 / scale);
}
// This is how much to expand buffers to account for filters seeking outside
// the image boundaries.
static int stbir__get_filter_pixel_margin(stbir_filter filter, float scale)
{
return stbir__get_filter_pixel_width(filter, scale) / 2;
}
static int stbir__get_coefficient_width(stbir_filter filter, float scale)
{
if (stbir__use_upsampling(scale))
return (int)ceil(stbir__filter_info_table[filter].support(1 / scale) * 2);
else
return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2);
}
static int stbir__get_contributors(float scale, stbir_filter filter, int input_size, int output_size)
{
if (stbir__use_upsampling(scale))
return output_size;
else
return (input_size + stbir__get_filter_pixel_margin(filter, scale) * 2);
}
static int stbir__get_total_horizontal_coefficients(stbir__info* info)
{
return info->horizontal_num_contributors
* stbir__get_coefficient_width (info->horizontal_filter, info->horizontal_scale);
}
static int stbir__get_total_vertical_coefficients(stbir__info* info)
{
return info->vertical_num_contributors
* stbir__get_coefficient_width (info->vertical_filter, info->vertical_scale);
}
static stbir__contributors* stbir__get_contributor(stbir__contributors* contributors, int n)
{
return &contributors[n];
}
// For perf reasons this code is duplicated in stbir__resample_horizontal_upsample/downsample,
// if you change it here change it there too.
static float* stbir__get_coefficient(float* coefficients, stbir_filter filter, float scale, int n, int c)
{
int width = stbir__get_coefficient_width(filter, scale);
return &coefficients[width*n + c];
}
static int stbir__edge_wrap_slow(stbir_edge edge, int n, int max)
{
switch (edge)
{
case STBIR_EDGE_ZERO:
return 0; // we'll decode the wrong pixel here, and then overwrite with 0s later
case STBIR_EDGE_CLAMP:
if (n < 0)
return 0;
if (n >= max)
return max - 1;
return n; // NOTREACHED
case STBIR_EDGE_REFLECT:
{
if (n < 0)
{
if (n < max)
return -n;
else
return max - 1;
}
if (n >= max)
{
int max2 = max * 2;
if (n >= max2)
return 0;
else
return max2 - n - 1;
}
return n; // NOTREACHED
}
case STBIR_EDGE_WRAP:
if (n >= 0)
return (n % max);
else
{
int m = (-n) % max;
if (m != 0)
m = max - m;
return (m);
}
// NOTREACHED
default:
STBIR_ASSERT(!"Unimplemented edge type");
return 0;
}
}
stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)
{
// avoid per-pixel switch
if (n >= 0 && n < max)
return n;
return stbir__edge_wrap_slow(edge, n, max);
}
// What input pixels contribute to this output pixel?
static void stbir__calculate_sample_range_upsample(int n, float out_filter_radius, float scale_ratio, float out_shift, int* in_first_pixel, int* in_last_pixel, float* in_center_of_out)
{
float out_pixel_center = (float)n + 0.5f;
float out_pixel_influence_lowerbound = out_pixel_center - out_filter_radius;
float out_pixel_influence_upperbound = out_pixel_center + out_filter_radius;
float in_pixel_influence_lowerbound = (out_pixel_influence_lowerbound + out_shift) / scale_ratio;
float in_pixel_influence_upperbound = (out_pixel_influence_upperbound + out_shift) / scale_ratio;
*in_center_of_out = (out_pixel_center + out_shift) / scale_ratio;
*in_first_pixel = (int)(floor(in_pixel_influence_lowerbound + 0.5));
*in_last_pixel = (int)(floor(in_pixel_influence_upperbound - 0.5));
}
// What output pixels does this input pixel contribute to?
static void stbir__calculate_sample_range_downsample(int n, float in_pixels_radius, float scale_ratio, float out_shift, int* out_first_pixel, int* out_last_pixel, float* out_center_of_in)
{
float in_pixel_center = (float)n + 0.5f;
float in_pixel_influence_lowerbound = in_pixel_center - in_pixels_radius;
float in_pixel_influence_upperbound = in_pixel_center + in_pixels_radius;
float out_pixel_influence_lowerbound = in_pixel_influence_lowerbound * scale_ratio - out_shift;
float out_pixel_influence_upperbound = in_pixel_influence_upperbound * scale_ratio - out_shift;
*out_center_of_in = in_pixel_center * scale_ratio - out_shift;
*out_first_pixel = (int)(floor(out_pixel_influence_lowerbound + 0.5));
*out_last_pixel = (int)(floor(out_pixel_influence_upperbound - 0.5));
}
static void stbir__calculate_coefficients_upsample(stbir_filter filter, float scale, int in_first_pixel, int in_last_pixel, float in_center_of_out, stbir__contributors* contributor, float* coefficient_group)
{
int i;
float total_filter = 0;
float filter_scale;
STBIR_ASSERT(in_last_pixel - in_first_pixel <= (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2)); // Taken directly from stbir__get_coefficient_width() which we can't call because we don't know if we're horizontal or vertical.
contributor->n0 = in_first_pixel;
contributor->n1 = in_last_pixel;
STBIR_ASSERT(contributor->n1 >= contributor->n0);
for (i = 0; i <= in_last_pixel - in_first_pixel; i++)
{
float in_pixel_center = (float)(i + in_first_pixel) + 0.5f;
coefficient_group[i] = stbir__filter_info_table[filter].kernel(in_center_of_out - in_pixel_center, 1 / scale);
// If the coefficient is zero, skip it. (Don't do the <0 check here, we want the influence of those outside pixels.)
if (i == 0 && !coefficient_group[i])
{
contributor->n0 = ++in_first_pixel;
i--;
continue;
}
total_filter += coefficient_group[i];
}
STBIR_ASSERT(stbir__filter_info_table[filter].kernel((float)(in_last_pixel + 1) + 0.5f - in_center_of_out, 1/scale) == 0);
STBIR_ASSERT(total_filter > 0.9);
STBIR_ASSERT(total_filter < 1.1f); // Make sure it's not way off.
// Make sure the sum of all coefficients is 1.
filter_scale = 1 / total_filter;
for (i = 0; i <= in_last_pixel - in_first_pixel; i++)
coefficient_group[i] *= filter_scale;
for (i = in_last_pixel - in_first_pixel; i >= 0; i--)
{
if (coefficient_group[i])
break;
// This line has no weight. We can skip it.
contributor->n1 = contributor->n0 + i - 1;
}
}
static void stbir__calculate_coefficients_downsample(stbir_filter filter, float scale_ratio, int out_first_pixel, int out_last_pixel, float out_center_of_in, stbir__contributors* contributor, float* coefficient_group)
{
int i;
STBIR_ASSERT(out_last_pixel - out_first_pixel <= (int)ceil(stbir__filter_info_table[filter].support(scale_ratio) * 2)); // Taken directly from stbir__get_coefficient_width() which we can't call because we don't know if we're horizontal or vertical.
contributor->n0 = out_first_pixel;
contributor->n1 = out_last_pixel;
STBIR_ASSERT(contributor->n1 >= contributor->n0);
for (i = 0; i <= out_last_pixel - out_first_pixel; i++)
{
float out_pixel_center = (float)(i + out_first_pixel) + 0.5f;
float x = out_pixel_center - out_center_of_in;
coefficient_group[i] = stbir__filter_info_table[filter].kernel(x, scale_ratio) * scale_ratio;
}
STBIR_ASSERT(stbir__filter_info_table[filter].kernel((float)(out_last_pixel + 1) + 0.5f - out_center_of_in, scale_ratio) == 0);
for (i = out_last_pixel - out_first_pixel; i >= 0; i--)
{
if (coefficient_group[i])
break;
// This line has no weight. We can skip it.
contributor->n1 = contributor->n0 + i - 1;
}
}
static void stbir__normalize_downsample_coefficients(stbir__contributors* contributors, float* coefficients, stbir_filter filter, float scale_ratio, int input_size, int output_size)
{
int num_contributors = stbir__get_contributors(scale_ratio, filter, input_size, output_size);
int num_coefficients = stbir__get_coefficient_width(filter, scale_ratio);
int i, j;
int skip;
for (i = 0; i < output_size; i++)
{
float scale;
float total = 0;
for (j = 0; j < num_contributors; j++)
{
if (i >= contributors[j].n0 && i <= contributors[j].n1)
{
float coefficient = *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i - contributors[j].n0);
total += coefficient;
}
else if (i < contributors[j].n0)
break;
}
STBIR_ASSERT(total > 0.9f);
STBIR_ASSERT(total < 1.1f);
scale = 1 / total;
for (j = 0; j < num_contributors; j++)
{
if (i >= contributors[j].n0 && i <= contributors[j].n1)
*stbir__get_coefficient(coefficients, filter, scale_ratio, j, i - contributors[j].n0) *= scale;
else if (i < contributors[j].n0)
break;
}
}
// Optimize: Skip zero coefficients and contributions outside of image bounds.
// Do this after normalizing because normalization depends on the n0/n1 values.
for (j = 0; j < num_contributors; j++)
{
int range, max, width;
skip = 0;
while (*stbir__get_coefficient(coefficients, filter, scale_ratio, j, skip) == 0)
skip++;
contributors[j].n0 += skip;
while (contributors[j].n0 < 0)
{
contributors[j].n0++;
skip++;
}
range = contributors[j].n1 - contributors[j].n0 + 1;
max = stbir__min(num_coefficients, range);
width = stbir__get_coefficient_width(filter, scale_ratio);
for (i = 0; i < max; i++)
{
if (i + skip >= width)
break;
*stbir__get_coefficient(coefficients, filter, scale_ratio, j, i) = *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i + skip);
}
continue;
}
// Using min to avoid writing into invalid pixels.
for (i = 0; i < num_contributors; i++)
contributors[i].n1 = stbir__min(contributors[i].n1, output_size - 1);
}
// Each scan line uses the same kernel values so we should calculate the kernel
// values once and then we can use them for every scan line.
static void stbir__calculate_filters(stbir__contributors* contributors, float* coefficients, stbir_filter filter, float scale_ratio, float shift, int input_size, int output_size)
{
int n;
int total_contributors = stbir__get_contributors(scale_ratio, filter, input_size, output_size);
if (stbir__use_upsampling(scale_ratio))
{
float out_pixels_radius = stbir__filter_info_table[filter].support(1 / scale_ratio) * scale_ratio;
// Looping through out pixels
for (n = 0; n < total_contributors; n++)
{
float in_center_of_out; // Center of the current out pixel in the in pixel space
int in_first_pixel, in_last_pixel;
stbir__calculate_sample_range_upsample(n, out_pixels_radius, scale_ratio, shift, &in_first_pixel, &in_last_pixel, &in_center_of_out);
stbir__calculate_coefficients_upsample(filter, scale_ratio, in_first_pixel, in_last_pixel, in_center_of_out, stbir__get_contributor(contributors, n), stbir__get_coefficient(coefficients, filter, scale_ratio, n, 0));
}
}
else
{
float in_pixels_radius = stbir__filter_info_table[filter].support(scale_ratio) / scale_ratio;
// Looping through in pixels
for (n = 0; n < total_contributors; n++)
{
float out_center_of_in; // Center of the current out pixel in the in pixel space
int out_first_pixel, out_last_pixel;
int n_adjusted = n - stbir__get_filter_pixel_margin(filter, scale_ratio);
stbir__calculate_sample_range_downsample(n_adjusted, in_pixels_radius, scale_ratio, shift, &out_first_pixel, &out_last_pixel, &out_center_of_in);
stbir__calculate_coefficients_downsample(filter, scale_ratio, out_first_pixel, out_last_pixel, out_center_of_in, stbir__get_contributor(contributors, n), stbir__get_coefficient(coefficients, filter, scale_ratio, n, 0));
}
stbir__normalize_downsample_coefficients(contributors, coefficients, filter, scale_ratio, input_size, output_size);
}
}
static float* stbir__get_decode_buffer(stbir__info* stbir_info)
{
// The 0 index of the decode buffer starts after the margin. This makes
// it okay to use negative indexes on the decode buffer.
return &stbir_info->decode_buffer[stbir_info->horizontal_filter_pixel_margin * stbir_info->channels];
}
#define STBIR__DECODE(type, colorspace) ((int)(type) * (STBIR_MAX_COLORSPACES) + (int)(colorspace))
static void stbir__decode_scanline(stbir__info* stbir_info, int n)
{
int c;
int channels = stbir_info->channels;
int alpha_channel = stbir_info->alpha_channel;
int type = stbir_info->type;
int colorspace = stbir_info->colorspace;
int input_w = stbir_info->input_w;
size_t input_stride_bytes = stbir_info->input_stride_bytes;
float* decode_buffer = stbir__get_decode_buffer(stbir_info);
stbir_edge edge_horizontal = stbir_info->edge_horizontal;
stbir_edge edge_vertical = stbir_info->edge_vertical;
size_t in_buffer_row_offset = stbir__edge_wrap(edge_vertical, n, stbir_info->input_h) * input_stride_bytes;
const void* input_data = (char *) stbir_info->input_data + in_buffer_row_offset;
int max_x = input_w + stbir_info->horizontal_filter_pixel_margin;
int decode = STBIR__DECODE(type, colorspace);
int x = -stbir_info->horizontal_filter_pixel_margin;
// special handling for STBIR_EDGE_ZERO because it needs to return an item that doesn't appear in the input,
// and we want to avoid paying overhead on every pixel if not STBIR_EDGE_ZERO
if (edge_vertical == STBIR_EDGE_ZERO && (n < 0 || n >= stbir_info->input_h))
{
for (; x < max_x; x++)
for (c = 0; c < channels; c++)
decode_buffer[x*channels + c] = 0;
return;
}
switch (decode)
{
case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR):
for (; x < max_x; x++)
{
int decode_pixel_index = x * channels;
int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
for (c = 0; c < channels; c++)
decode_buffer[decode_pixel_index + c] = ((float)((const unsigned char*)input_data)[input_pixel_index + c]) / stbir__max_uint8_as_float;
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB):
for (; x < max_x; x++)
{
int decode_pixel_index = x * channels;
int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
for (c = 0; c < channels; c++)
decode_buffer[decode_pixel_index + c] = stbir__srgb_uchar_to_linear_float[((const unsigned char*)input_data)[input_pixel_index + c]];
if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned char*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint8_as_float;
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR):
for (; x < max_x; x++)
{
int decode_pixel_index = x * channels;
int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
for (c = 0; c < channels; c++)
decode_buffer[decode_pixel_index + c] = ((float)((const unsigned short*)input_data)[input_pixel_index + c]) / stbir__max_uint16_as_float;
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB):
for (; x < max_x; x++)
{
int decode_pixel_index = x * channels;
int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
for (c = 0; c < channels; c++)
decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((float)((const unsigned short*)input_data)[input_pixel_index + c]) / stbir__max_uint16_as_float);
if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned short*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint16_as_float;
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR):
for (; x < max_x; x++)
{
int decode_pixel_index = x * channels;
int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
for (c = 0; c < channels; c++)
decode_buffer[decode_pixel_index + c] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / stbir__max_uint32_as_float);
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB):
for (; x < max_x; x++)
{
int decode_pixel_index = x * channels;
int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
for (c = 0; c < channels; c++)
decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear((float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / stbir__max_uint32_as_float));
if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
decode_buffer[decode_pixel_index + alpha_channel] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint32_as_float);
}
break;
case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR):
for (; x < max_x; x++)
{
int decode_pixel_index = x * channels;
int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
for (c = 0; c < channels; c++)
decode_buffer[decode_pixel_index + c] = ((const float*)input_data)[input_pixel_index + c];
}
break;
case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB):
for (; x < max_x; x++)
{
int decode_pixel_index = x * channels;
int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
for (c = 0; c < channels; c++)
decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((const float*)input_data)[input_pixel_index + c]);
if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
decode_buffer[decode_pixel_index + alpha_channel] = ((const float*)input_data)[input_pixel_index + alpha_channel];
}
break;
default:
STBIR_ASSERT(!"Unknown type/colorspace/channels combination.");
break;
}
if (!(stbir_info->flags & STBIR_FLAG_ALPHA_PREMULTIPLIED))
{
for (x = -stbir_info->horizontal_filter_pixel_margin; x < max_x; x++)
{
int decode_pixel_index = x * channels;
// If the alpha value is 0 it will clobber the color values. Make sure it's not.
float alpha = decode_buffer[decode_pixel_index + alpha_channel];
#ifndef STBIR_NO_ALPHA_EPSILON
if (stbir_info->type != STBIR_TYPE_FLOAT) {
alpha += STBIR_ALPHA_EPSILON;
decode_buffer[decode_pixel_index + alpha_channel] = alpha;
}
#endif
for (c = 0; c < channels; c++)
{
if (c == alpha_channel)
continue;
decode_buffer[decode_pixel_index + c] *= alpha;
}
}
}
if (edge_horizontal == STBIR_EDGE_ZERO)
{
for (x = -stbir_info->horizontal_filter_pixel_margin; x < 0; x++)
{
for (c = 0; c < channels; c++)
decode_buffer[x*channels + c] = 0;
}
for (x = input_w; x < max_x; x++)
{
for (c = 0; c < channels; c++)
decode_buffer[x*channels + c] = 0;
}
}
}
static float* stbir__get_ring_buffer_entry(float* ring_buffer, int index, int ring_buffer_length)
{
return &ring_buffer[index * ring_buffer_length];
}
static float* stbir__add_empty_ring_buffer_entry(stbir__info* stbir_info, int n)
{
int ring_buffer_index;
float* ring_buffer;
stbir_info->ring_buffer_last_scanline = n;
if (stbir_info->ring_buffer_begin_index < 0)
{
ring_buffer_index = stbir_info->ring_buffer_begin_index = 0;
stbir_info->ring_buffer_first_scanline = n;
}
else
{
ring_buffer_index = (stbir_info->ring_buffer_begin_index + (stbir_info->ring_buffer_last_scanline - stbir_info->ring_buffer_first_scanline)) % stbir_info->ring_buffer_num_entries;
STBIR_ASSERT(ring_buffer_index != stbir_info->ring_buffer_begin_index);
}
ring_buffer = stbir__get_ring_buffer_entry(stbir_info->ring_buffer, ring_buffer_index, stbir_info->ring_buffer_length_bytes / sizeof(float));
memset(ring_buffer, 0, stbir_info->ring_buffer_length_bytes);
return ring_buffer;
}
static void stbir__resample_horizontal_upsample(stbir__info* stbir_info, float* output_buffer)
{
int x, k;
int output_w = stbir_info->output_w;
int channels = stbir_info->channels;
float* decode_buffer = stbir__get_decode_buffer(stbir_info);
stbir__contributors* horizontal_contributors = stbir_info->horizontal_contributors;
float* horizontal_coefficients = stbir_info->horizontal_coefficients;
int coefficient_width = stbir_info->horizontal_coefficient_width;
for (x = 0; x < output_w; x++)
{
int n0 = horizontal_contributors[x].n0;
int n1 = horizontal_contributors[x].n1;
int out_pixel_index = x * channels;
int coefficient_group = coefficient_width * x;
int coefficient_counter = 0;
STBIR_ASSERT(n1 >= n0);
STBIR_ASSERT(n0 >= -stbir_info->horizontal_filter_pixel_margin);
STBIR_ASSERT(n1 >= -stbir_info->horizontal_filter_pixel_margin);
STBIR_ASSERT(n0 < stbir_info->input_w + stbir_info->horizontal_filter_pixel_margin);
STBIR_ASSERT(n1 < stbir_info->input_w + stbir_info->horizontal_filter_pixel_margin);
switch (channels) {
case 1:
for (k = n0; k <= n1; k++)
{
int in_pixel_index = k * 1;
float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
STBIR_ASSERT(coefficient != 0);
output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
}
break;
case 2:
for (k = n0; k <= n1; k++)
{
int in_pixel_index = k * 2;
float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
STBIR_ASSERT(coefficient != 0);
output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
}
break;
case 3:
for (k = n0; k <= n1; k++)
{
int in_pixel_index = k * 3;
float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
STBIR_ASSERT(coefficient != 0);
output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;
}
break;
case 4:
for (k = n0; k <= n1; k++)
{
int in_pixel_index = k * 4;
float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
STBIR_ASSERT(coefficient != 0);
output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;
output_buffer[out_pixel_index + 3] += decode_buffer[in_pixel_index + 3] * coefficient;
}
break;
default:
for (k = n0; k <= n1; k++)
{
int in_pixel_index = k * channels;
float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
int c;
STBIR_ASSERT(coefficient != 0);
for (c = 0; c < channels; c++)
output_buffer[out_pixel_index + c] += decode_buffer[in_pixel_index + c] * coefficient;
}
break;
}
}
}
static void stbir__resample_horizontal_downsample(stbir__info* stbir_info, float* output_buffer)
{
int x, k;
int input_w = stbir_info->input_w;
int channels = stbir_info->channels;
float* decode_buffer = stbir__get_decode_buffer(stbir_info);
stbir__contributors* horizontal_contributors = stbir_info->horizontal_contributors;
float* horizontal_coefficients = stbir_info->horizontal_coefficients;
int coefficient_width = stbir_info->horizontal_coefficient_width;
int filter_pixel_margin = stbir_info->horizontal_filter_pixel_margin;
int max_x = input_w + filter_pixel_margin * 2;
STBIR_ASSERT(!stbir__use_width_upsampling(stbir_info));
switch (channels) {
case 1:
for (x = 0; x < max_x; x++)
{
int n0 = horizontal_contributors[x].n0;
int n1 = horizontal_contributors[x].n1;
int in_x = x - filter_pixel_margin;
int in_pixel_index = in_x * 1;
int max_n = n1;
int coefficient_group = coefficient_width * x;
for (k = n0; k <= max_n; k++)
{
int out_pixel_index = k * 1;
float coefficient = horizontal_coefficients[coefficient_group + k - n0];
STBIR_ASSERT(coefficient != 0);
output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
}
}
break;
case 2:
for (x = 0; x < max_x; x++)
{
int n0 = horizontal_contributors[x].n0;
int n1 = horizontal_contributors[x].n1;
int in_x = x - filter_pixel_margin;
int in_pixel_index = in_x * 2;
int max_n = n1;
int coefficient_group = coefficient_width * x;
for (k = n0; k <= max_n; k++)
{
int out_pixel_index = k * 2;
float coefficient = horizontal_coefficients[coefficient_group + k - n0];
STBIR_ASSERT(coefficient != 0);
output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
}
}
break;
case 3:
for (x = 0; x < max_x; x++)
{
int n0 = horizontal_contributors[x].n0;
int n1 = horizontal_contributors[x].n1;
int in_x = x - filter_pixel_margin;
int in_pixel_index = in_x * 3;
int max_n = n1;
int coefficient_group = coefficient_width * x;
for (k = n0; k <= max_n; k++)
{
int out_pixel_index = k * 3;
float coefficient = horizontal_coefficients[coefficient_group + k - n0];
STBIR_ASSERT(coefficient != 0);
output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;
}
}
break;
case 4:
for (x = 0; x < max_x; x++)
{
int n0 = horizontal_contributors[x].n0;
int n1 = horizontal_contributors[x].n1;
int in_x = x - filter_pixel_margin;
int in_pixel_index = in_x * 4;
int max_n = n1;
int coefficient_group = coefficient_width * x;
for (k = n0; k <= max_n; k++)
{
int out_pixel_index = k * 4;
float coefficient = horizontal_coefficients[coefficient_group + k - n0];
STBIR_ASSERT(coefficient != 0);
output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;
output_buffer[out_pixel_index + 3] += decode_buffer[in_pixel_index + 3] * coefficient;
}
}
break;
default:
for (x = 0; x < max_x; x++)
{
int n0 = horizontal_contributors[x].n0;
int n1 = horizontal_contributors[x].n1;
int in_x = x - filter_pixel_margin;
int in_pixel_index = in_x * channels;
int max_n = n1;
int coefficient_group = coefficient_width * x;
for (k = n0; k <= max_n; k++)
{
int c;
int out_pixel_index = k * channels;
float coefficient = horizontal_coefficients[coefficient_group + k - n0];
STBIR_ASSERT(coefficient != 0);
for (c = 0; c < channels; c++)
output_buffer[out_pixel_index + c] += decode_buffer[in_pixel_index + c] * coefficient;
}
}
break;
}
}
static void stbir__decode_and_resample_upsample(stbir__info* stbir_info, int n)
{
// Decode the nth scanline from the source image into the decode buffer.
stbir__decode_scanline(stbir_info, n);
// Now resample it into the ring buffer.
if (stbir__use_width_upsampling(stbir_info))
stbir__resample_horizontal_upsample(stbir_info, stbir__add_empty_ring_buffer_entry(stbir_info, n));
else
stbir__resample_horizontal_downsample(stbir_info, stbir__add_empty_ring_buffer_entry(stbir_info, n));
// Now it's sitting in the ring buffer ready to be used as source for the vertical sampling.
}
static void stbir__decode_and_resample_downsample(stbir__info* stbir_info, int n)
{
// Decode the nth scanline from the source image into the decode buffer.
stbir__decode_scanline(stbir_info, n);
memset(stbir_info->horizontal_buffer, 0, stbir_info->output_w * stbir_info->channels * sizeof(float));
// Now resample it into the horizontal buffer.
if (stbir__use_width_upsampling(stbir_info))
stbir__resample_horizontal_upsample(stbir_info, stbir_info->horizontal_buffer);
else
stbir__resample_horizontal_downsample(stbir_info, stbir_info->horizontal_buffer);
// Now it's sitting in the horizontal buffer ready to be distributed into the ring buffers.
}
// Get the specified scan line from the ring buffer.
static float* stbir__get_ring_buffer_scanline(int get_scanline, float* ring_buffer, int begin_index, int first_scanline, int ring_buffer_num_entries, int ring_buffer_length)
{
int ring_buffer_index = (begin_index + (get_scanline - first_scanline)) % ring_buffer_num_entries;
return stbir__get_ring_buffer_entry(ring_buffer, ring_buffer_index, ring_buffer_length);
}
static void stbir__encode_scanline(stbir__info* stbir_info, int num_pixels, void *output_buffer, float *encode_buffer, int channels, int alpha_channel, int decode)
{
int x;
int n;
int num_nonalpha;
stbir_uint16 nonalpha[STBIR_MAX_CHANNELS];
if (!(stbir_info->flags&STBIR_FLAG_ALPHA_PREMULTIPLIED))
{
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
float alpha = encode_buffer[pixel_index + alpha_channel];
float reciprocal_alpha = alpha ? 1.0f / alpha : 0;
// unrolling this produced a 1% slowdown upscaling a large RGBA linear-space image on my machine - stb
for (n = 0; n < channels; n++)
if (n != alpha_channel)
encode_buffer[pixel_index + n] *= reciprocal_alpha;
// We added in a small epsilon to prevent the color channel from being deleted with zero alpha.
// Because we only add it for integer types, it will automatically be discarded on integer
// conversion, so we don't need to subtract it back out (which would be problematic for
// numeric precision reasons).
}
}
// build a table of all channels that need colorspace correction, so
// we don't perform colorspace correction on channels that don't need it.
for (x = 0, num_nonalpha = 0; x < channels; ++x)
{
if (x != alpha_channel || (stbir_info->flags & STBIR_FLAG_ALPHA_USES_COLORSPACE))
{
nonalpha[num_nonalpha++] = (stbir_uint16)x;
}
}
#define STBIR__ROUND_INT(f) ((int) ((f)+0.5))
#define STBIR__ROUND_UINT(f) ((stbir_uint32) ((f)+0.5))
#ifdef STBIR__SATURATE_INT
#define STBIR__ENCODE_LINEAR8(f) stbir__saturate8 (STBIR__ROUND_INT((f) * stbir__max_uint8_as_float ))
#define STBIR__ENCODE_LINEAR16(f) stbir__saturate16(STBIR__ROUND_INT((f) * stbir__max_uint16_as_float))
#else
#define STBIR__ENCODE_LINEAR8(f) (unsigned char ) STBIR__ROUND_INT(stbir__saturate(f) * stbir__max_uint8_as_float )
#define STBIR__ENCODE_LINEAR16(f) (unsigned short) STBIR__ROUND_INT(stbir__saturate(f) * stbir__max_uint16_as_float)
#endif
switch (decode)
{
case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR):
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
for (n = 0; n < channels; n++)
{
int index = pixel_index + n;
((unsigned char*)output_buffer)[index] = STBIR__ENCODE_LINEAR8(encode_buffer[index]);
}
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB):
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
for (n = 0; n < num_nonalpha; n++)
{
int index = pixel_index + nonalpha[n];
((unsigned char*)output_buffer)[index] = stbir__linear_to_srgb_uchar(encode_buffer[index]);
}
if (!(stbir_info->flags & STBIR_FLAG_ALPHA_USES_COLORSPACE))
((unsigned char *)output_buffer)[pixel_index + alpha_channel] = STBIR__ENCODE_LINEAR8(encode_buffer[pixel_index+alpha_channel]);
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR):
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
for (n = 0; n < channels; n++)
{
int index = pixel_index + n;
((unsigned short*)output_buffer)[index] = STBIR__ENCODE_LINEAR16(encode_buffer[index]);
}
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB):
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
for (n = 0; n < num_nonalpha; n++)
{
int index = pixel_index + nonalpha[n];
((unsigned short*)output_buffer)[index] = (unsigned short)STBIR__ROUND_INT(stbir__linear_to_srgb(stbir__saturate(encode_buffer[index])) * stbir__max_uint16_as_float);
}
if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
((unsigned short*)output_buffer)[pixel_index + alpha_channel] = STBIR__ENCODE_LINEAR16(encode_buffer[pixel_index + alpha_channel]);
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR):
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
for (n = 0; n < channels; n++)
{
int index = pixel_index + n;
((unsigned int*)output_buffer)[index] = (unsigned int)STBIR__ROUND_UINT(((double)stbir__saturate(encode_buffer[index])) * stbir__max_uint32_as_float);
}
}
break;
case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB):
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
for (n = 0; n < num_nonalpha; n++)
{
int index = pixel_index + nonalpha[n];
((unsigned int*)output_buffer)[index] = (unsigned int)STBIR__ROUND_UINT(((double)stbir__linear_to_srgb(stbir__saturate(encode_buffer[index]))) * stbir__max_uint32_as_float);
}
if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
((unsigned int*)output_buffer)[pixel_index + alpha_channel] = (unsigned int)STBIR__ROUND_INT(((double)stbir__saturate(encode_buffer[pixel_index + alpha_channel])) * stbir__max_uint32_as_float);
}
break;
case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR):
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
for (n = 0; n < channels; n++)
{
int index = pixel_index + n;
((float*)output_buffer)[index] = encode_buffer[index];
}
}
break;
case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB):
for (x=0; x < num_pixels; ++x)
{
int pixel_index = x*channels;
for (n = 0; n < num_nonalpha; n++)
{
int index = pixel_index + nonalpha[n];
((float*)output_buffer)[index] = stbir__linear_to_srgb(encode_buffer[index]);
}
if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
((float*)output_buffer)[pixel_index + alpha_channel] = encode_buffer[pixel_index + alpha_channel];
}
break;
default:
STBIR_ASSERT(!"Unknown type/colorspace/channels combination.");
break;
}
}
static void stbir__resample_vertical_upsample(stbir__info* stbir_info, int n)
{
int x, k;
int output_w = stbir_info->output_w;
stbir__contributors* vertical_contributors = stbir_info->vertical_contributors;
float* vertical_coefficients = stbir_info->vertical_coefficients;
int channels = stbir_info->channels;
int alpha_channel = stbir_info->alpha_channel;
int type = stbir_info->type;
int colorspace = stbir_info->colorspace;
int ring_buffer_entries = stbir_info->ring_buffer_num_entries;
void* output_data = stbir_info->output_data;
float* encode_buffer = stbir_info->encode_buffer;
int decode = STBIR__DECODE(type, colorspace);
int coefficient_width = stbir_info->vertical_coefficient_width;
int coefficient_counter;
int contributor = n;
float* ring_buffer = stbir_info->ring_buffer;
int ring_buffer_begin_index = stbir_info->ring_buffer_begin_index;
int ring_buffer_first_scanline = stbir_info->ring_buffer_first_scanline;
int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);
int n0,n1, output_row_start;
int coefficient_group = coefficient_width * contributor;
n0 = vertical_contributors[contributor].n0;
n1 = vertical_contributors[contributor].n1;
output_row_start = n * stbir_info->output_stride_bytes;
STBIR_ASSERT(stbir__use_height_upsampling(stbir_info));
memset(encode_buffer, 0, output_w * sizeof(float) * channels);
// I tried reblocking this for better cache usage of encode_buffer
// (using x_outer, k, x_inner), but it lost speed. -- stb
coefficient_counter = 0;
switch (channels) {
case 1:
for (k = n0; k <= n1; k++)
{
int coefficient_index = coefficient_counter++;
float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
for (x = 0; x < output_w; ++x)
{
int in_pixel_index = x * 1;
encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;
}
}
break;
case 2:
for (k = n0; k <= n1; k++)
{
int coefficient_index = coefficient_counter++;
float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
for (x = 0; x < output_w; ++x)
{
int in_pixel_index = x * 2;
encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;
encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;
}
}
break;
case 3:
for (k = n0; k <= n1; k++)
{
int coefficient_index = coefficient_counter++;
float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
for (x = 0; x < output_w; ++x)
{
int in_pixel_index = x * 3;
encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;
encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;
encode_buffer[in_pixel_index + 2] += ring_buffer_entry[in_pixel_index + 2] * coefficient;
}
}
break;
case 4:
for (k = n0; k <= n1; k++)
{
int coefficient_index = coefficient_counter++;
float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
for (x = 0; x < output_w; ++x)
{
int in_pixel_index = x * 4;
encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;
encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;
encode_buffer[in_pixel_index + 2] += ring_buffer_entry[in_pixel_index + 2] * coefficient;
encode_buffer[in_pixel_index + 3] += ring_buffer_entry[in_pixel_index + 3] * coefficient;
}
}
break;
default:
for (k = n0; k <= n1; k++)
{
int coefficient_index = coefficient_counter++;
float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
for (x = 0; x < output_w; ++x)
{
int in_pixel_index = x * channels;
int c;
for (c = 0; c < channels; c++)
encode_buffer[in_pixel_index + c] += ring_buffer_entry[in_pixel_index + c] * coefficient;
}
}
break;
}
stbir__encode_scanline(stbir_info, output_w, (char *) output_data + output_row_start, encode_buffer, channels, alpha_channel, decode);
}
static void stbir__resample_vertical_downsample(stbir__info* stbir_info, int n)
{
int x, k;
int output_w = stbir_info->output_w;
stbir__contributors* vertical_contributors = stbir_info->vertical_contributors;
float* vertical_coefficients = stbir_info->vertical_coefficients;
int channels = stbir_info->channels;
int ring_buffer_entries = stbir_info->ring_buffer_num_entries;
float* horizontal_buffer = stbir_info->horizontal_buffer;
int coefficient_width = stbir_info->vertical_coefficient_width;
int contributor = n + stbir_info->vertical_filter_pixel_margin;
float* ring_buffer = stbir_info->ring_buffer;
int ring_buffer_begin_index = stbir_info->ring_buffer_begin_index;
int ring_buffer_first_scanline = stbir_info->ring_buffer_first_scanline;
int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);
int n0,n1;
n0 = vertical_contributors[contributor].n0;
n1 = vertical_contributors[contributor].n1;
STBIR_ASSERT(!stbir__use_height_upsampling(stbir_info));
for (k = n0; k <= n1; k++)
{
int coefficient_index = k - n0;
int coefficient_group = coefficient_width * contributor;
float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
switch (channels) {
case 1:
for (x = 0; x < output_w; x++)
{
int in_pixel_index = x * 1;
ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;
}
break;
case 2:
for (x = 0; x < output_w; x++)
{
int in_pixel_index = x * 2;
ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;
ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;
}
break;
case 3:
for (x = 0; x < output_w; x++)
{
int in_pixel_index = x * 3;
ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;
ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;
ring_buffer_entry[in_pixel_index + 2] += horizontal_buffer[in_pixel_index + 2] * coefficient;
}
break;
case 4:
for (x = 0; x < output_w; x++)
{
int in_pixel_index = x * 4;
ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;
ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;
ring_buffer_entry[in_pixel_index + 2] += horizontal_buffer[in_pixel_index + 2] * coefficient;
ring_buffer_entry[in_pixel_index + 3] += horizontal_buffer[in_pixel_index + 3] * coefficient;
}
break;
default:
for (x = 0; x < output_w; x++)
{
int in_pixel_index = x * channels;
int c;
for (c = 0; c < channels; c++)
ring_buffer_entry[in_pixel_index + c] += horizontal_buffer[in_pixel_index + c] * coefficient;
}
break;
}
}
}
static void stbir__buffer_loop_upsample(stbir__info* stbir_info)
{
int y;
float scale_ratio = stbir_info->vertical_scale;
float out_scanlines_radius = stbir__filter_info_table[stbir_info->vertical_filter].support(1/scale_ratio) * scale_ratio;
STBIR_ASSERT(stbir__use_height_upsampling(stbir_info));
for (y = 0; y < stbir_info->output_h; y++)
{
float in_center_of_out = 0; // Center of the current out scanline in the in scanline space
int in_first_scanline = 0, in_last_scanline = 0;
stbir__calculate_sample_range_upsample(y, out_scanlines_radius, scale_ratio, stbir_info->vertical_shift, &in_first_scanline, &in_last_scanline, &in_center_of_out);
STBIR_ASSERT(in_last_scanline - in_first_scanline + 1 <= stbir_info->ring_buffer_num_entries);
if (stbir_info->ring_buffer_begin_index >= 0)
{
// Get rid of whatever we don't need anymore.
while (in_first_scanline > stbir_info->ring_buffer_first_scanline)
{
if (stbir_info->ring_buffer_first_scanline == stbir_info->ring_buffer_last_scanline)
{
// We just popped the last scanline off the ring buffer.
// Reset it to the empty state.
stbir_info->ring_buffer_begin_index = -1;
stbir_info->ring_buffer_first_scanline = 0;
stbir_info->ring_buffer_last_scanline = 0;
break;
}
else
{
stbir_info->ring_buffer_first_scanline++;
stbir_info->ring_buffer_begin_index = (stbir_info->ring_buffer_begin_index + 1) % stbir_info->ring_buffer_num_entries;
}
}
}
// Load in new ones.
if (stbir_info->ring_buffer_begin_index < 0)
stbir__decode_and_resample_upsample(stbir_info, in_first_scanline);
while (in_last_scanline > stbir_info->ring_buffer_last_scanline)
stbir__decode_and_resample_upsample(stbir_info, stbir_info->ring_buffer_last_scanline + 1);
// Now all buffers should be ready to write a row of vertical sampling.
stbir__resample_vertical_upsample(stbir_info, y);
STBIR_PROGRESS_REPORT((float)y / stbir_info->output_h);
}
}
static void stbir__empty_ring_buffer(stbir__info* stbir_info, int first_necessary_scanline)
{
int output_stride_bytes = stbir_info->output_stride_bytes;
int channels = stbir_info->channels;
int alpha_channel = stbir_info->alpha_channel;
int type = stbir_info->type;
int colorspace = stbir_info->colorspace;
int output_w = stbir_info->output_w;
void* output_data = stbir_info->output_data;
int decode = STBIR__DECODE(type, colorspace);
float* ring_buffer = stbir_info->ring_buffer;
int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);
if (stbir_info->ring_buffer_begin_index >= 0)
{
// Get rid of whatever we don't need anymore.
while (first_necessary_scanline > stbir_info->ring_buffer_first_scanline)
{
if (stbir_info->ring_buffer_first_scanline >= 0 && stbir_info->ring_buffer_first_scanline < stbir_info->output_h)
{
int output_row_start = stbir_info->ring_buffer_first_scanline * output_stride_bytes;
float* ring_buffer_entry = stbir__get_ring_buffer_entry(ring_buffer, stbir_info->ring_buffer_begin_index, ring_buffer_length);
stbir__encode_scanline(stbir_info, output_w, (char *) output_data + output_row_start, ring_buffer_entry, channels, alpha_channel, decode);
STBIR_PROGRESS_REPORT((float)stbir_info->ring_buffer_first_scanline / stbir_info->output_h);
}
if (stbir_info->ring_buffer_first_scanline == stbir_info->ring_buffer_last_scanline)
{
// We just popped the last scanline off the ring buffer.
// Reset it to the empty state.
stbir_info->ring_buffer_begin_index = -1;
stbir_info->ring_buffer_first_scanline = 0;
stbir_info->ring_buffer_last_scanline = 0;
break;
}
else
{
stbir_info->ring_buffer_first_scanline++;
stbir_info->ring_buffer_begin_index = (stbir_info->ring_buffer_begin_index + 1) % stbir_info->ring_buffer_num_entries;
}
}
}
}
static void stbir__buffer_loop_downsample(stbir__info* stbir_info)
{
int y;
float scale_ratio = stbir_info->vertical_scale;
int output_h = stbir_info->output_h;
float in_pixels_radius = stbir__filter_info_table[stbir_info->vertical_filter].support(scale_ratio) / scale_ratio;
int pixel_margin = stbir_info->vertical_filter_pixel_margin;
int max_y = stbir_info->input_h + pixel_margin;
STBIR_ASSERT(!stbir__use_height_upsampling(stbir_info));
for (y = -pixel_margin; y < max_y; y++)
{
float out_center_of_in; // Center of the current out scanline in the in scanline space
int out_first_scanline, out_last_scanline;
stbir__calculate_sample_range_downsample(y, in_pixels_radius, scale_ratio, stbir_info->vertical_shift, &out_first_scanline, &out_last_scanline, &out_center_of_in);
STBIR_ASSERT(out_last_scanline - out_first_scanline + 1 <= stbir_info->ring_buffer_num_entries);
if (out_last_scanline < 0 || out_first_scanline >= output_h)
continue;
stbir__empty_ring_buffer(stbir_info, out_first_scanline);
stbir__decode_and_resample_downsample(stbir_info, y);
// Load in new ones.
if (stbir_info->ring_buffer_begin_index < 0)
stbir__add_empty_ring_buffer_entry(stbir_info, out_first_scanline);
while (out_last_scanline > stbir_info->ring_buffer_last_scanline)
stbir__add_empty_ring_buffer_entry(stbir_info, stbir_info->ring_buffer_last_scanline + 1);
// Now the horizontal buffer is ready to write to all ring buffer rows.
stbir__resample_vertical_downsample(stbir_info, y);
}
stbir__empty_ring_buffer(stbir_info, stbir_info->output_h);
}
static void stbir__setup(stbir__info *info, int input_w, int input_h, int output_w, int output_h, int channels)
{
info->input_w = input_w;
info->input_h = input_h;
info->output_w = output_w;
info->output_h = output_h;
info->channels = channels;
}
static void stbir__calculate_transform(stbir__info *info, float s0, float t0, float s1, float t1, float *transform)
{
info->s0 = s0;
info->t0 = t0;
info->s1 = s1;
info->t1 = t1;
if (transform)
{
info->horizontal_scale = transform[0];
info->vertical_scale = transform[1];
info->horizontal_shift = transform[2];
info->vertical_shift = transform[3];
}
else
{
info->horizontal_scale = ((float)info->output_w / info->input_w) / (s1 - s0);
info->vertical_scale = ((float)info->output_h / info->input_h) / (t1 - t0);
info->horizontal_shift = s0 * info->output_w / (s1 - s0);
info->vertical_shift = t0 * info->output_h / (t1 - t0);
}
}
static void stbir__choose_filter(stbir__info *info, stbir_filter h_filter, stbir_filter v_filter)
{
if (h_filter == 0)
h_filter = stbir__use_upsampling(info->horizontal_scale) ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE;
if (v_filter == 0)
v_filter = stbir__use_upsampling(info->vertical_scale) ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE;
info->horizontal_filter = h_filter;
info->vertical_filter = v_filter;
}
static stbir_uint32 stbir__calculate_memory(stbir__info *info)
{
int pixel_margin = stbir__get_filter_pixel_margin(info->horizontal_filter, info->horizontal_scale);
int filter_height = stbir__get_filter_pixel_width(info->vertical_filter, info->vertical_scale);
info->horizontal_num_contributors = stbir__get_contributors(info->horizontal_scale, info->horizontal_filter, info->input_w, info->output_w);
info->vertical_num_contributors = stbir__get_contributors(info->vertical_scale , info->vertical_filter , info->input_h, info->output_h);
// One extra entry because floating point precision problems sometimes cause an extra to be necessary.
info->ring_buffer_num_entries = filter_height + 1;
info->horizontal_contributors_size = info->horizontal_num_contributors * sizeof(stbir__contributors);
info->horizontal_coefficients_size = stbir__get_total_horizontal_coefficients(info) * sizeof(float);
info->vertical_contributors_size = info->vertical_num_contributors * sizeof(stbir__contributors);
info->vertical_coefficients_size = stbir__get_total_vertical_coefficients(info) * sizeof(float);
info->decode_buffer_size = (info->input_w + pixel_margin * 2) * info->channels * sizeof(float);
info->horizontal_buffer_size = info->output_w * info->channels * sizeof(float);
info->ring_buffer_size = info->output_w * info->channels * info->ring_buffer_num_entries * sizeof(float);
info->encode_buffer_size = info->output_w * info->channels * sizeof(float);
STBIR_ASSERT(info->horizontal_filter != 0);
STBIR_ASSERT(info->horizontal_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); // this now happens too late
STBIR_ASSERT(info->vertical_filter != 0);
STBIR_ASSERT(info->vertical_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); // this now happens too late
if (stbir__use_height_upsampling(info))
// The horizontal buffer is for when we're downsampling the height and we
// can't output the result of sampling the decode buffer directly into the
// ring buffers.
info->horizontal_buffer_size = 0;
else
// The encode buffer is to retain precision in the height upsampling method
// and isn't used when height downsampling.
info->encode_buffer_size = 0;
return info->horizontal_contributors_size + info->horizontal_coefficients_size
+ info->vertical_contributors_size + info->vertical_coefficients_size
+ info->decode_buffer_size + info->horizontal_buffer_size
+ info->ring_buffer_size + info->encode_buffer_size;
}
static int stbir__resize_allocated(stbir__info *info,
const void* input_data, int input_stride_in_bytes,
void* output_data, int output_stride_in_bytes,
int alpha_channel, stbir_uint32 flags, stbir_datatype type,
stbir_edge edge_horizontal, stbir_edge edge_vertical, stbir_colorspace colorspace,
void* tempmem, size_t tempmem_size_in_bytes)
{
size_t memory_required = stbir__calculate_memory(info);
int width_stride_input = input_stride_in_bytes ? input_stride_in_bytes : info->channels * info->input_w * stbir__type_size[type];
int width_stride_output = output_stride_in_bytes ? output_stride_in_bytes : info->channels * info->output_w * stbir__type_size[type];
#ifdef STBIR_DEBUG_OVERWRITE_TEST
#define OVERWRITE_ARRAY_SIZE 8
unsigned char overwrite_output_before_pre[OVERWRITE_ARRAY_SIZE];
unsigned char overwrite_tempmem_before_pre[OVERWRITE_ARRAY_SIZE];
unsigned char overwrite_output_after_pre[OVERWRITE_ARRAY_SIZE];
unsigned char overwrite_tempmem_after_pre[OVERWRITE_ARRAY_SIZE];
size_t begin_forbidden = width_stride_output * (info->output_h - 1) + info->output_w * info->channels * stbir__type_size[type];
memcpy(overwrite_output_before_pre, &((unsigned char*)output_data)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE);
memcpy(overwrite_output_after_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE);
memcpy(overwrite_tempmem_before_pre, &((unsigned char*)tempmem)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE);
memcpy(overwrite_tempmem_after_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE);
#endif
STBIR_ASSERT(info->channels >= 0);
STBIR_ASSERT(info->channels <= STBIR_MAX_CHANNELS);
if (info->channels < 0 || info->channels > STBIR_MAX_CHANNELS)
return 0;
STBIR_ASSERT(info->horizontal_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));
STBIR_ASSERT(info->vertical_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));
if (info->horizontal_filter >= STBIR__ARRAY_SIZE(stbir__filter_info_table))
return 0;
if (info->vertical_filter >= STBIR__ARRAY_SIZE(stbir__filter_info_table))
return 0;
if (alpha_channel < 0)
flags |= STBIR_FLAG_ALPHA_USES_COLORSPACE | STBIR_FLAG_ALPHA_PREMULTIPLIED;
if (!(flags&STBIR_FLAG_ALPHA_USES_COLORSPACE) || !(flags&STBIR_FLAG_ALPHA_PREMULTIPLIED)) {
STBIR_ASSERT(alpha_channel >= 0 && alpha_channel < info->channels);
}
if (alpha_channel >= info->channels)
return 0;
STBIR_ASSERT(tempmem);
if (!tempmem)
return 0;
STBIR_ASSERT(tempmem_size_in_bytes >= memory_required);
if (tempmem_size_in_bytes < memory_required)
return 0;
memset(tempmem, 0, tempmem_size_in_bytes);
info->input_data = input_data;
info->input_stride_bytes = width_stride_input;
info->output_data = output_data;
info->output_stride_bytes = width_stride_output;
info->alpha_channel = alpha_channel;
info->flags = flags;
info->type = type;
info->edge_horizontal = edge_horizontal;
info->edge_vertical = edge_vertical;
info->colorspace = colorspace;
info->horizontal_coefficient_width = stbir__get_coefficient_width (info->horizontal_filter, info->horizontal_scale);
info->vertical_coefficient_width = stbir__get_coefficient_width (info->vertical_filter , info->vertical_scale );
info->horizontal_filter_pixel_width = stbir__get_filter_pixel_width (info->horizontal_filter, info->horizontal_scale);
info->vertical_filter_pixel_width = stbir__get_filter_pixel_width (info->vertical_filter , info->vertical_scale );
info->horizontal_filter_pixel_margin = stbir__get_filter_pixel_margin(info->horizontal_filter, info->horizontal_scale);
info->vertical_filter_pixel_margin = stbir__get_filter_pixel_margin(info->vertical_filter , info->vertical_scale );
info->ring_buffer_length_bytes = info->output_w * info->channels * sizeof(float);
info->decode_buffer_pixels = info->input_w + info->horizontal_filter_pixel_margin * 2;
#define STBIR__NEXT_MEMPTR(current, newtype) (newtype*)(((unsigned char*)current) + current##_size)
info->horizontal_contributors = (stbir__contributors *) tempmem;
info->horizontal_coefficients = STBIR__NEXT_MEMPTR(info->horizontal_contributors, float);
info->vertical_contributors = STBIR__NEXT_MEMPTR(info->horizontal_coefficients, stbir__contributors);
info->vertical_coefficients = STBIR__NEXT_MEMPTR(info->vertical_contributors, float);
info->decode_buffer = STBIR__NEXT_MEMPTR(info->vertical_coefficients, float);
if (stbir__use_height_upsampling(info))
{
info->horizontal_buffer = NULL;
info->ring_buffer = STBIR__NEXT_MEMPTR(info->decode_buffer, float);
info->encode_buffer = STBIR__NEXT_MEMPTR(info->ring_buffer, float);
STBIR_ASSERT((size_t)STBIR__NEXT_MEMPTR(info->encode_buffer, unsigned char) == (size_t)tempmem + tempmem_size_in_bytes);
}
else
{
info->horizontal_buffer = STBIR__NEXT_MEMPTR(info->decode_buffer, float);
info->ring_buffer = STBIR__NEXT_MEMPTR(info->horizontal_buffer, float);
info->encode_buffer = NULL;
STBIR_ASSERT((size_t)STBIR__NEXT_MEMPTR(info->ring_buffer, unsigned char) == (size_t)tempmem + tempmem_size_in_bytes);
}
#undef STBIR__NEXT_MEMPTR
// This signals that the ring buffer is empty
info->ring_buffer_begin_index = -1;
stbir__calculate_filters(info->horizontal_contributors, info->horizontal_coefficients, info->horizontal_filter, info->horizontal_scale, info->horizontal_shift, info->input_w, info->output_w);
stbir__calculate_filters(info->vertical_contributors, info->vertical_coefficients, info->vertical_filter, info->vertical_scale, info->vertical_shift, info->input_h, info->output_h);
STBIR_PROGRESS_REPORT(0);
if (stbir__use_height_upsampling(info))
stbir__buffer_loop_upsample(info);
else
stbir__buffer_loop_downsample(info);
STBIR_PROGRESS_REPORT(1);
#ifdef STBIR_DEBUG_OVERWRITE_TEST
STBIR_ASSERT(memcmp(overwrite_output_before_pre, &((unsigned char*)output_data)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE) == 0);
STBIR_ASSERT(memcmp(overwrite_output_after_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE) == 0);
STBIR_ASSERT(memcmp(overwrite_tempmem_before_pre, &((unsigned char*)tempmem)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE) == 0);
STBIR_ASSERT(memcmp(overwrite_tempmem_after_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE) == 0);
#endif
return 1;
}
static int stbir__resize_arbitrary(
void *alloc_context,
const void* input_data, int input_w, int input_h, int input_stride_in_bytes,
void* output_data, int output_w, int output_h, int output_stride_in_bytes,
float s0, float t0, float s1, float t1, float *transform,
int channels, int alpha_channel, stbir_uint32 flags, stbir_datatype type,
stbir_filter h_filter, stbir_filter v_filter,
stbir_edge edge_horizontal, stbir_edge edge_vertical, stbir_colorspace colorspace)
{
stbir__info info;
int result;
size_t memory_required;
void* extra_memory;
stbir__setup(&info, input_w, input_h, output_w, output_h, channels);
stbir__calculate_transform(&info, s0,t0,s1,t1,transform);
stbir__choose_filter(&info, h_filter, v_filter);
memory_required = stbir__calculate_memory(&info);
extra_memory = STBIR_MALLOC(memory_required, alloc_context);
if (!extra_memory)
return 0;
result = stbir__resize_allocated(&info, input_data, input_stride_in_bytes,
output_data, output_stride_in_bytes,
alpha_channel, flags, type,
edge_horizontal, edge_vertical,
colorspace, extra_memory, memory_required);
STBIR_FREE(extra_memory, alloc_context);
return result;
}
STBIRDEF int stbir_resize_uint8( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels)
{
return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,NULL,num_channels,-1,0, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_LINEAR);
}
STBIRDEF int stbir_resize_float( const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels)
{
return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,NULL,num_channels,-1,0, STBIR_TYPE_FLOAT, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_LINEAR);
}
STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags)
{
return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_SRGB);
}
STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_wrap_mode)
{
return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
edge_wrap_mode, edge_wrap_mode, STBIR_COLORSPACE_SRGB);
}
STBIRDEF int stbir_resize_uint8_generic( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
void *alloc_context)
{
return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, filter, filter,
edge_wrap_mode, edge_wrap_mode, space);
}
STBIRDEF int stbir_resize_uint16_generic(const stbir_uint16 *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
stbir_uint16 *output_pixels , int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
void *alloc_context)
{
return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT16, filter, filter,
edge_wrap_mode, edge_wrap_mode, space);
}
STBIRDEF int stbir_resize_float_generic( const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
float *output_pixels , int output_w, int output_h, int output_stride_in_bytes,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
void *alloc_context)
{
return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_FLOAT, filter, filter,
edge_wrap_mode, edge_wrap_mode, space);
}
STBIRDEF int stbir_resize( const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
stbir_datatype datatype,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
stbir_filter filter_horizontal, stbir_filter filter_vertical,
stbir_colorspace space, void *alloc_context)
{
return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,
edge_mode_horizontal, edge_mode_vertical, space);
}
STBIRDEF int stbir_resize_subpixel(const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
stbir_datatype datatype,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
stbir_filter filter_horizontal, stbir_filter filter_vertical,
stbir_colorspace space, void *alloc_context,
float x_scale, float y_scale,
float x_offset, float y_offset)
{
float transform[4];
transform[0] = x_scale;
transform[1] = y_scale;
transform[2] = x_offset;
transform[3] = y_offset;
return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
0,0,1,1,transform,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,
edge_mode_horizontal, edge_mode_vertical, space);
}
STBIRDEF int stbir_resize_region( const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
stbir_datatype datatype,
int num_channels, int alpha_channel, int flags,
stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
stbir_filter filter_horizontal, stbir_filter filter_vertical,
stbir_colorspace space, void *alloc_context,
float s0, float t0, float s1, float t1)
{
return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
output_pixels, output_w, output_h, output_stride_in_bytes,
s0,t0,s1,t1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,
edge_mode_horizontal, edge_mode_vertical, space);
}
#endif // STB_IMAGE_RESIZE_IMPLEMENTATION
/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2017 Sean Barrett
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
*/
| 116,073 | C | 43.101064 | 253 | 0.614691 |
NVIDIA-Omniverse/AnariUsdDevice/thirdparty/stb_image/stb_image.h | /* stb_image - v2.26 - public domain image loader - http://nothings.org/stb
no warranty implied; use at your own risk
Do this:
#define STB_IMAGE_IMPLEMENTATION
before you include this file in *one* C or C++ file to create the implementation.
// i.e. it should look like this:
#include ...
#include ...
#include ...
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
QUICK NOTES:
Primarily of interest to game developers and other people who can
avoid problematic images and only need the trivial interface
JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
PNG 1/2/4/8/16-bit-per-channel
TGA (not sure what subset, if a subset)
BMP non-1bpp, non-RLE
PSD (composited view only, no extra channels, 8/16 bit-per-channel)
GIF (*comp always reports as 4-channel)
HDR (radiance rgbE format)
PIC (Softimage PIC)
PNM (PPM and PGM binary only)
Animated GIF still needs a proper API, but here's one way to do it:
http://gist.github.com/urraka/685d9a6340b26b830d49
- decode from memory or through FILE (define STBI_NO_STDIO to remove code)
- decode from arbitrary I/O callbacks
- SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
Full documentation under "DOCUMENTATION" below.
LICENSE
See end of file for license information.
RECENT REVISION HISTORY:
2.26 (2020-07-13) many minor fixes
2.25 (2020-02-02) fix warnings
2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
2.23 (2019-08-11) fix clang static analysis warning
2.22 (2019-03-04) gif fixes, fix warnings
2.21 (2019-02-25) fix typo in comment
2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
2.19 (2018-02-11) fix warning
2.18 (2018-01-30) fix warnings
2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
RGB-format JPEG; remove white matting in PSD;
allocate large structures on the stack;
correct channel count for PNG & BMP
2.10 (2016-01-22) avoid warning introduced in 2.09
2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
See end of file for full revision history.
============================ Contributors =========================
Image formats Extensions, features
Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info)
Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info)
Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG)
Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks)
Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG)
Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip)
Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD)
github:urraka (animated gif) Junggon Kim (PNM comments)
Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA)
socks-the-fox (16-bit PNG)
Jeremy Sawicki (handle all ImageNet JPGs)
Optimizations & bugfixes Mikhail Morozov (1-bit BMP)
Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query)
Arseny Kapoulkine
John-Mark Allen
Carmelo J Fdez-Aguera
Bug & warning fixes
Marc LeBlanc David Woo Guillaume George Martins Mozeiko
Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski
Phil Jordan Dave Moore Roy Eltham
Hayaki Saito Nathan Reed Won Chun
Luke Graham Johan Duparc Nick Verigakis the Horde3D community
Thomas Ruf Ronny Chevalier github:rlyeh
Janez Zemva John Bartholomew Michal Cichon github:romigrou
Jonathan Blow Ken Hamada Tero Hanninen github:svdijk
Laurent Gomila Cort Stratton github:snagar
Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex
Cass Everitt Ryamond Barbiero github:grim210
Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw
Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus
Josh Tobin Matthew Gregan github:poppolopoppo
Julian Raschke Gregory Mullen Christian Floisand github:darealshinji
Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007
Brad Weinberger Matvey Cherevko [reserved]
Luca Sas Alexander Veselov Zack Middleton [reserved]
Ryan C. Gordon [reserved] [reserved]
DO NOT ADD YOUR NAME HERE
To add your name to the credits, pick a random blank space in the middle and fill it.
80% of merge conflicts on stb PRs are due to people adding their name at the end
of the credits.
*/
#ifndef STBI_INCLUDE_STB_IMAGE_H
#define STBI_INCLUDE_STB_IMAGE_H
// DOCUMENTATION
//
// Limitations:
// - no 12-bit-per-channel JPEG
// - no JPEGs with arithmetic coding
// - GIF always returns *comp=4
//
// Basic usage (see HDR discussion below for HDR usage):
// int x,y,n;
// unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
// // ... process data if not NULL ...
// // ... x = width, y = height, n = # 8-bit components per pixel ...
// // ... replace '0' with '1'..'4' to force that many components per pixel
// // ... but 'n' will always be the number that it would have been if you said 0
// stbi_image_free(data)
//
// Standard parameters:
// int *x -- outputs image width in pixels
// int *y -- outputs image height in pixels
// int *channels_in_file -- outputs # of image components in image file
// int desired_channels -- if non-zero, # of image components requested in result
//
// The return value from an image loader is an 'unsigned char *' which points
// to the pixel data, or NULL on an allocation failure or if the image is
// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
// with each pixel consisting of N interleaved 8-bit components; the first
// pixel pointed to is top-left-most in the image. There is no padding between
// image scanlines or between pixels, regardless of format. The number of
// components N is 'desired_channels' if desired_channels is non-zero, or
// *channels_in_file otherwise. If desired_channels is non-zero,
// *channels_in_file has the number of components that _would_ have been
// output otherwise. E.g. if you set desired_channels to 4, you will always
// get RGBA output, but you can check *channels_in_file to see if it's trivially
// opaque because e.g. there were only 3 channels in the source image.
//
// An output image with N components has the following components interleaved
// in this order in each pixel:
//
// N=#comp components
// 1 grey
// 2 grey, alpha
// 3 red, green, blue
// 4 red, green, blue, alpha
//
// If image loading fails for any reason, the return value will be NULL,
// and *x, *y, *channels_in_file will be unchanged. The function
// stbi_failure_reason() can be queried for an extremely brief, end-user
// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
// more user-friendly ones.
//
// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
//
// ===========================================================================
//
// UNICODE:
//
// If compiling for Windows and you wish to use Unicode filenames, compile
// with
// #define STBI_WINDOWS_UTF8
// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
// Windows wchar_t filenames to utf8.
//
// ===========================================================================
//
// Philosophy
//
// stb libraries are designed with the following priorities:
//
// 1. easy to use
// 2. easy to maintain
// 3. good performance
//
// Sometimes I let "good performance" creep up in priority over "easy to maintain",
// and for best performance I may provide less-easy-to-use APIs that give higher
// performance, in addition to the easy-to-use ones. Nevertheless, it's important
// to keep in mind that from the standpoint of you, a client of this library,
// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
//
// Some secondary priorities arise directly from the first two, some of which
// provide more explicit reasons why performance can't be emphasized.
//
// - Portable ("ease of use")
// - Small source code footprint ("easy to maintain")
// - No dependencies ("ease of use")
//
// ===========================================================================
//
// I/O callbacks
//
// I/O callbacks allow you to read from arbitrary sources, like packaged
// files or some other source. Data read from callbacks are processed
// through a small internal buffer (currently 128 bytes) to try to reduce
// overhead.
//
// The three functions you must define are "read" (reads some bytes of data),
// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
//
// ===========================================================================
//
// SIMD support
//
// The JPEG decoder will try to automatically use SIMD kernels on x86 when
// supported by the compiler. For ARM Neon support, you must explicitly
// request it.
//
// (The old do-it-yourself SIMD API is no longer supported in the current
// code.)
//
// On x86, SSE2 will automatically be used when available based on a run-time
// test; if not, the generic C versions are used as a fall-back. On ARM targets,
// the typical path is to have separate builds for NEON and non-NEON devices
// (at least this is true for iOS and Android). Therefore, the NEON support is
// toggled by a build flag: define STBI_NEON to get NEON loops.
//
// If for some reason you do not want to use any of SIMD code, or if
// you have issues compiling it, you can disable it entirely by
// defining STBI_NO_SIMD.
//
// ===========================================================================
//
// HDR image support (disable by defining STBI_NO_HDR)
//
// stb_image supports loading HDR images in general, and currently the Radiance
// .HDR file format specifically. You can still load any file through the existing
// interface; if you attempt to load an HDR file, it will be automatically remapped
// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
// both of these constants can be reconfigured through this interface:
//
// stbi_hdr_to_ldr_gamma(2.2f);
// stbi_hdr_to_ldr_scale(1.0f);
//
// (note, do not use _inverse_ constants; stbi_image will invert them
// appropriately).
//
// Additionally, there is a new, parallel interface for loading files as
// (linear) floats to preserve the full dynamic range:
//
// float *data = stbi_loadf(filename, &x, &y, &n, 0);
//
// If you load LDR images through this interface, those images will
// be promoted to floating point values, run through the inverse of
// constants corresponding to the above:
//
// stbi_ldr_to_hdr_scale(1.0f);
// stbi_ldr_to_hdr_gamma(2.2f);
//
// Finally, given a filename (or an open file or memory block--see header
// file for details) containing image data, you can query for the "most
// appropriate" interface to use (that is, whether the image is HDR or
// not), using:
//
// stbi_is_hdr(char *filename);
//
// ===========================================================================
//
// iPhone PNG support:
//
// By default we convert iphone-formatted PNGs back to RGB, even though
// they are internally encoded differently. You can disable this conversion
// by calling stbi_convert_iphone_png_to_rgb(0), in which case
// you will always just get the native iphone "format" through (which
// is BGR stored in RGB).
//
// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
// pixel to remove any premultiplied alpha *only* if the image file explicitly
// says there's premultiplied data (currently only happens in iPhone images,
// and only if iPhone convert-to-rgb processing is on).
//
// ===========================================================================
//
// ADDITIONAL CONFIGURATION
//
// - You can suppress implementation of any of the decoders to reduce
// your code footprint by #defining one or more of the following
// symbols before creating the implementation.
//
// STBI_NO_JPEG
// STBI_NO_PNG
// STBI_NO_BMP
// STBI_NO_PSD
// STBI_NO_TGA
// STBI_NO_GIF
// STBI_NO_HDR
// STBI_NO_PIC
// STBI_NO_PNM (.ppm and .pgm)
//
// - You can request *only* certain decoders and suppress all other ones
// (this will be more forward-compatible, as addition of new decoders
// doesn't require you to disable them explicitly):
//
// STBI_ONLY_JPEG
// STBI_ONLY_PNG
// STBI_ONLY_BMP
// STBI_ONLY_PSD
// STBI_ONLY_TGA
// STBI_ONLY_GIF
// STBI_ONLY_HDR
// STBI_ONLY_PIC
// STBI_ONLY_PNM (.ppm and .pgm)
//
// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
//
// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
// than that size (in either width or height) without further processing.
// This is to let programs in the wild set an upper bound to prevent
// denial-of-service attacks on untrusted data, as one could generate a
// valid image of gigantic dimensions and force stb_image to allocate a
// huge block of memory and spend disproportionate time decoding it. By
// default this is set to (1 << 24), which is 16777216, but that's still
// very big.
#ifndef STBI_NO_STDIO
#include <stdio.h>
#endif // STBI_NO_STDIO
#define STBI_VERSION 1
enum
{
STBI_default = 0, // only used for desired_channels
STBI_grey = 1,
STBI_grey_alpha = 2,
STBI_rgb = 3,
STBI_rgb_alpha = 4
};
#include <stdlib.h>
typedef unsigned char stbi_uc;
typedef unsigned short stbi_us;
#ifdef __cplusplus
extern "C" {
#endif
#ifndef STBIDEF
#ifdef STB_IMAGE_STATIC
#define STBIDEF static
#else
#define STBIDEF extern
#endif
#endif
//////////////////////////////////////////////////////////////////////////////
//
// PRIMARY API - works on images of any type
//
//
// load image by filename, open file, or memory buffer
//
typedef struct
{
int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read
void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
int (*eof) (void *user); // returns nonzero if we are at end of file/data
} stbi_io_callbacks;
////////////////////////////////////
//
// 8-bits-per-channel interface
//
STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
#ifndef STBI_NO_STDIO
STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
// for stbi_load_from_file, file pointer is left pointing immediately after image
#endif
#ifndef STBI_NO_GIF
STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
#endif
#ifdef STBI_WINDOWS_UTF8
STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
#endif
////////////////////////////////////
//
// 16-bits-per-channel interface
//
STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
#ifndef STBI_NO_STDIO
STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
#endif
////////////////////////////////////
//
// float-per-channel interface
//
#ifndef STBI_NO_LINEAR
STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
#ifndef STBI_NO_STDIO
STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
#endif
#endif
#ifndef STBI_NO_HDR
STBIDEF void stbi_hdr_to_ldr_gamma(float gamma);
STBIDEF void stbi_hdr_to_ldr_scale(float scale);
#endif // STBI_NO_HDR
#ifndef STBI_NO_LINEAR
STBIDEF void stbi_ldr_to_hdr_gamma(float gamma);
STBIDEF void stbi_ldr_to_hdr_scale(float scale);
#endif // STBI_NO_LINEAR
// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
#ifndef STBI_NO_STDIO
STBIDEF int stbi_is_hdr (char const *filename);
STBIDEF int stbi_is_hdr_from_file(FILE *f);
#endif // STBI_NO_STDIO
// get a VERY brief reason for failure
// on most compilers (and ALL modern mainstream compilers) this is threadsafe
STBIDEF const char *stbi_failure_reason (void);
// free the loaded image -- this is just free()
STBIDEF void stbi_image_free (void *retval_from_stbi_load);
// get image dimensions & components without fully decoding
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
#ifndef STBI_NO_STDIO
STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp);
STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);
STBIDEF int stbi_is_16_bit (char const *filename);
STBIDEF int stbi_is_16_bit_from_file(FILE *f);
#endif
// for image formats that explicitly notate that they have premultiplied alpha,
// we just return the colors as stored in the file. set this flag to force
// unpremultiplication. results are undefined if the unpremultiply overflow.
STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
// indicate whether we should process iphone images back to canonical format,
// or just pass them through "as-is"
STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
// flip the image vertically, so the first pixel in the output array is the bottom left
STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
// as above, but only applies to images loaded on the thread that calls the function
// this function is only available if your compiler supports thread-local variables;
// calling it will fail to link if your compiler doesn't
STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
// ZLIB client - used by PNG, available for other purposes
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
#ifdef __cplusplus
}
#endif
//
//
//// end header file /////////////////////////////////////////////////////
#endif // STBI_INCLUDE_STB_IMAGE_H
#ifdef STB_IMAGE_IMPLEMENTATION
#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
|| defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
|| defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
|| defined(STBI_ONLY_ZLIB)
#ifndef STBI_ONLY_JPEG
#define STBI_NO_JPEG
#endif
#ifndef STBI_ONLY_PNG
#define STBI_NO_PNG
#endif
#ifndef STBI_ONLY_BMP
#define STBI_NO_BMP
#endif
#ifndef STBI_ONLY_PSD
#define STBI_NO_PSD
#endif
#ifndef STBI_ONLY_TGA
#define STBI_NO_TGA
#endif
#ifndef STBI_ONLY_GIF
#define STBI_NO_GIF
#endif
#ifndef STBI_ONLY_HDR
#define STBI_NO_HDR
#endif
#ifndef STBI_ONLY_PIC
#define STBI_NO_PIC
#endif
#ifndef STBI_ONLY_PNM
#define STBI_NO_PNM
#endif
#endif
#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
#define STBI_NO_ZLIB
#endif
#include <stdarg.h>
#include <stddef.h> // ptrdiff_t on osx
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
#include <math.h> // ldexp, pow
#endif
#ifndef STBI_NO_STDIO
#include <stdio.h>
#endif
#ifndef STBI_ASSERT
#include <assert.h>
#define STBI_ASSERT(x) assert(x)
#endif
#ifdef __cplusplus
#define STBI_EXTERN extern "C"
#else
#define STBI_EXTERN extern
#endif
#ifndef _MSC_VER
#ifdef __cplusplus
#define stbi_inline inline
#else
#define stbi_inline
#endif
#else
#define stbi_inline __forceinline
#endif
#ifndef STBI_NO_THREAD_LOCALS
#if defined(__cplusplus) && __cplusplus >= 201103L
#define STBI_THREAD_LOCAL thread_local
#elif defined(__GNUC__) && __GNUC__ < 5
#define STBI_THREAD_LOCAL __thread
#elif defined(_MSC_VER)
#define STBI_THREAD_LOCAL __declspec(thread)
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
#define STBI_THREAD_LOCAL _Thread_local
#endif
#ifndef STBI_THREAD_LOCAL
#if defined(__GNUC__)
#define STBI_THREAD_LOCAL __thread
#endif
#endif
#endif
#ifdef _MSC_VER
typedef unsigned short stbi__uint16;
typedef signed short stbi__int16;
typedef unsigned int stbi__uint32;
typedef signed int stbi__int32;
#else
#include <stdint.h>
typedef uint16_t stbi__uint16;
typedef int16_t stbi__int16;
typedef uint32_t stbi__uint32;
typedef int32_t stbi__int32;
#endif
// should produce compiler error if size is wrong
typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
#ifdef _MSC_VER
#define STBI_NOTUSED(v) (void)(v)
#else
#define STBI_NOTUSED(v) (void)sizeof(v)
#endif
#ifdef _MSC_VER
#define STBI_HAS_LROTL
#endif
#ifdef STBI_HAS_LROTL
#define stbi_lrot(x,y) _lrotl(x,y)
#else
#define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y))))
#endif
#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
// ok
#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
// ok
#else
#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
#endif
#ifndef STBI_MALLOC
#define STBI_MALLOC(sz) malloc(sz)
#define STBI_REALLOC(p,newsz) realloc(p,newsz)
#define STBI_FREE(p) free(p)
#endif
#ifndef STBI_REALLOC_SIZED
#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
#endif
// x86/x64 detection
#if defined(__x86_64__) || defined(_M_X64)
#define STBI__X64_TARGET
#elif defined(__i386) || defined(_M_IX86)
#define STBI__X86_TARGET
#endif
#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
// but previous attempts to provide the SSE2 functions with runtime
// detection caused numerous issues. The way architecture extensions are
// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
// New behavior: if compiled with -msse2, we use SSE2 without any
// detection; if not, we don't use it at all.
#define STBI_NO_SIMD
#endif
#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
//
// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
// simultaneously enabling "-mstackrealign".
//
// See https://github.com/nothings/stb/issues/81 for more information.
//
// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
#define STBI_NO_SIMD
#endif
#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
#define STBI_SSE2
#include <emmintrin.h>
#ifdef _MSC_VER
#if _MSC_VER >= 1400 // not VC6
#include <intrin.h> // __cpuid
static int stbi__cpuid3(void)
{
int info[4];
__cpuid(info,1);
return info[3];
}
#else
static int stbi__cpuid3(void)
{
int res;
__asm {
mov eax,1
cpuid
mov res,edx
}
return res;
}
#endif
#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
static int stbi__sse2_available(void)
{
int info3 = stbi__cpuid3();
return ((info3 >> 26) & 1) != 0;
}
#endif
#else // assume GCC-style if not VC++
#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
static int stbi__sse2_available(void)
{
// If we're even attempting to compile this on GCC/Clang, that means
// -msse2 is on, which means the compiler is allowed to use SSE2
// instructions at will, and so are we.
return 1;
}
#endif
#endif
#endif
// ARM NEON
#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
#undef STBI_NEON
#endif
#ifdef STBI_NEON
#include <arm_neon.h>
// assume GCC or Clang on ARM targets
#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
#endif
#ifndef STBI_SIMD_ALIGN
#define STBI_SIMD_ALIGN(type, name) type name
#endif
#ifndef STBI_MAX_DIMENSIONS
#define STBI_MAX_DIMENSIONS (1 << 24)
#endif
///////////////////////////////////////////////
//
// stbi__context struct and start_xxx functions
// stbi__context structure is our basic context used by all images, so it
// contains all the IO context, plus some basic image information
typedef struct
{
stbi__uint32 img_x, img_y;
int img_n, img_out_n;
stbi_io_callbacks io;
void *io_user_data;
int read_from_callbacks;
int buflen;
stbi_uc buffer_start[128];
int callback_already_read;
stbi_uc *img_buffer, *img_buffer_end;
stbi_uc *img_buffer_original, *img_buffer_original_end;
} stbi__context;
static void stbi__refill_buffer(stbi__context *s);
// initialize a memory-decode context
static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
{
s->io.read = NULL;
s->read_from_callbacks = 0;
s->callback_already_read = 0;
s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
}
// initialize a callback-based context
static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
{
s->io = *c;
s->io_user_data = user;
s->buflen = sizeof(s->buffer_start);
s->read_from_callbacks = 1;
s->callback_already_read = 0;
s->img_buffer = s->img_buffer_original = s->buffer_start;
stbi__refill_buffer(s);
s->img_buffer_original_end = s->img_buffer_end;
}
#ifndef STBI_NO_STDIO
static int stbi__stdio_read(void *user, char *data, int size)
{
return (int) fread(data,1,size,(FILE*) user);
}
static void stbi__stdio_skip(void *user, int n)
{
int ch;
fseek((FILE*) user, n, SEEK_CUR);
ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */
if (ch != EOF) {
ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */
}
}
static int stbi__stdio_eof(void *user)
{
return feof((FILE*) user) || ferror((FILE *) user);
}
static stbi_io_callbacks stbi__stdio_callbacks =
{
stbi__stdio_read,
stbi__stdio_skip,
stbi__stdio_eof,
};
static void stbi__start_file(stbi__context *s, FILE *f)
{
stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
}
//static void stop_file(stbi__context *s) { }
#endif // !STBI_NO_STDIO
static void stbi__rewind(stbi__context *s)
{
// conceptually rewind SHOULD rewind to the beginning of the stream,
// but we just rewind to the beginning of the initial buffer, because
// we only use it after doing 'test', which only ever looks at at most 92 bytes
s->img_buffer = s->img_buffer_original;
s->img_buffer_end = s->img_buffer_original_end;
}
enum
{
STBI_ORDER_RGB,
STBI_ORDER_BGR
};
typedef struct
{
int bits_per_channel;
int num_channels;
int channel_order;
} stbi__result_info;
#ifndef STBI_NO_JPEG
static int stbi__jpeg_test(stbi__context *s);
static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
#endif
#ifndef STBI_NO_PNG
static int stbi__png_test(stbi__context *s);
static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
static int stbi__png_is16(stbi__context *s);
#endif
#ifndef STBI_NO_BMP
static int stbi__bmp_test(stbi__context *s);
static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
#endif
#ifndef STBI_NO_TGA
static int stbi__tga_test(stbi__context *s);
static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
#endif
#ifndef STBI_NO_PSD
static int stbi__psd_test(stbi__context *s);
static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
static int stbi__psd_is16(stbi__context *s);
#endif
#ifndef STBI_NO_HDR
static int stbi__hdr_test(stbi__context *s);
static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
#endif
#ifndef STBI_NO_PIC
static int stbi__pic_test(stbi__context *s);
static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
#endif
#ifndef STBI_NO_GIF
static int stbi__gif_test(stbi__context *s);
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
#endif
#ifndef STBI_NO_PNM
static int stbi__pnm_test(stbi__context *s);
static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
#endif
static
#ifdef STBI_THREAD_LOCAL
STBI_THREAD_LOCAL
#endif
const char *stbi__g_failure_reason;
STBIDEF const char *stbi_failure_reason(void)
{
return stbi__g_failure_reason;
}
#ifndef STBI_NO_FAILURE_STRINGS
static int stbi__err(const char *str)
{
stbi__g_failure_reason = str;
return 0;
}
#endif
static void *stbi__malloc(size_t size)
{
return STBI_MALLOC(size);
}
// stb_image uses ints pervasively, including for offset calculations.
// therefore the largest decoded image size we can support with the
// current code, even on 64-bit targets, is INT_MAX. this is not a
// significant limitation for the intended use case.
//
// we do, however, need to make sure our size calculations don't
// overflow. hence a few helper functions for size calculations that
// multiply integers together, making sure that they're non-negative
// and no overflow occurs.
// return 1 if the sum is valid, 0 on overflow.
// negative terms are considered invalid.
static int stbi__addsizes_valid(int a, int b)
{
if (b < 0) return 0;
// now 0 <= b <= INT_MAX, hence also
// 0 <= INT_MAX - b <= INTMAX.
// And "a + b <= INT_MAX" (which might overflow) is the
// same as a <= INT_MAX - b (no overflow)
return a <= INT_MAX - b;
}
// returns 1 if the product is valid, 0 on overflow.
// negative factors are considered invalid.
static int stbi__mul2sizes_valid(int a, int b)
{
if (a < 0 || b < 0) return 0;
if (b == 0) return 1; // mul-by-0 is always safe
// portable way to check for no overflows in a*b
return a <= INT_MAX/b;
}
#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
static int stbi__mad2sizes_valid(int a, int b, int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
}
#endif
// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
static int stbi__mad3sizes_valid(int a, int b, int c, int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
stbi__addsizes_valid(a*b*c, add);
}
// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
}
#endif
#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
// mallocs with size overflow checking
static void *stbi__malloc_mad2(int a, int b, int add)
{
if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
return stbi__malloc(a*b + add);
}
#endif
static void *stbi__malloc_mad3(int a, int b, int c, int add)
{
if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
return stbi__malloc(a*b*c + add);
}
#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
{
if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
return stbi__malloc(a*b*c*d + add);
}
#endif
// stbi__err - error
// stbi__errpf - error returning pointer to float
// stbi__errpuc - error returning pointer to unsigned char
#ifdef STBI_NO_FAILURE_STRINGS
#define stbi__err(x,y) 0
#elif defined(STBI_FAILURE_USERMSG)
#define stbi__err(x,y) stbi__err(y)
#else
#define stbi__err(x,y) stbi__err(x)
#endif
#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
STBIDEF void stbi_image_free(void *retval_from_stbi_load)
{
STBI_FREE(retval_from_stbi_load);
}
#ifndef STBI_NO_LINEAR
static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
#endif
#ifndef STBI_NO_HDR
static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);
#endif
static int stbi__vertically_flip_on_load_global = 0;
STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
{
stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
}
#ifndef STBI_THREAD_LOCAL
#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global
#else
static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
{
stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
stbi__vertically_flip_on_load_set = 1;
}
#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \
? stbi__vertically_flip_on_load_local \
: stbi__vertically_flip_on_load_global)
#endif // STBI_THREAD_LOCAL
static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
{
memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
ri->num_channels = 0;
#ifndef STBI_NO_JPEG
if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
#endif
#ifndef STBI_NO_PNG
if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri);
#endif
#ifndef STBI_NO_BMP
if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri);
#endif
#ifndef STBI_NO_GIF
if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri);
#endif
#ifndef STBI_NO_PSD
if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
#else
STBI_NOTUSED(bpc);
#endif
#ifndef STBI_NO_PIC
if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri);
#endif
#ifndef STBI_NO_PNM
if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri);
#endif
#ifndef STBI_NO_HDR
if (stbi__hdr_test(s)) {
float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
}
#endif
#ifndef STBI_NO_TGA
// test tga last because it's a crappy test!
if (stbi__tga_test(s))
return stbi__tga_load(s,x,y,comp,req_comp, ri);
#endif
return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
}
static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
{
int i;
int img_len = w * h * channels;
stbi_uc *reduced;
reduced = (stbi_uc *) stbi__malloc(img_len);
if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
for (i = 0; i < img_len; ++i)
reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
STBI_FREE(orig);
return reduced;
}
static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
{
int i;
int img_len = w * h * channels;
stbi__uint16 *enlarged;
enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
for (i = 0; i < img_len; ++i)
enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
STBI_FREE(orig);
return enlarged;
}
static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
{
int row;
size_t bytes_per_row = (size_t)w * bytes_per_pixel;
stbi_uc temp[2048];
stbi_uc *bytes = (stbi_uc *)image;
for (row = 0; row < (h>>1); row++) {
stbi_uc *row0 = bytes + row*bytes_per_row;
stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
// swap row0 with row1
size_t bytes_left = bytes_per_row;
while (bytes_left) {
size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
memcpy(temp, row0, bytes_copy);
memcpy(row0, row1, bytes_copy);
memcpy(row1, temp, bytes_copy);
row0 += bytes_copy;
row1 += bytes_copy;
bytes_left -= bytes_copy;
}
}
}
#ifndef STBI_NO_GIF
static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
{
int slice;
int slice_size = w * h * bytes_per_pixel;
stbi_uc *bytes = (stbi_uc *)image;
for (slice = 0; slice < z; ++slice) {
stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
bytes += slice_size;
}
}
#endif
static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
stbi__result_info ri;
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
if (result == NULL)
return NULL;
// it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
if (ri.bits_per_channel != 8) {
result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
ri.bits_per_channel = 8;
}
// @TODO: move stbi__convert_format to here
if (stbi__vertically_flip_on_load) {
int channels = req_comp ? req_comp : *comp;
stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
}
return (unsigned char *) result;
}
static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
stbi__result_info ri;
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
if (result == NULL)
return NULL;
// it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
if (ri.bits_per_channel != 16) {
result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
ri.bits_per_channel = 16;
}
// @TODO: move stbi__convert_format16 to here
// @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
if (stbi__vertically_flip_on_load) {
int channels = req_comp ? req_comp : *comp;
stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
}
return (stbi__uint16 *) result;
}
#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
{
if (stbi__vertically_flip_on_load && result != NULL) {
int channels = req_comp ? req_comp : *comp;
stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
}
}
#endif
#ifndef STBI_NO_STDIO
#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
#endif
#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
{
return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
}
#endif
static FILE *stbi__fopen(char const *filename, char const *mode)
{
FILE *f;
#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
wchar_t wMode[64];
wchar_t wFilename[1024];
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)))
return 0;
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)))
return 0;
#if _MSC_VER >= 1400
if (0 != _wfopen_s(&f, wFilename, wMode))
f = 0;
#else
f = _wfopen(wFilename, wMode);
#endif
#elif defined(_MSC_VER) && _MSC_VER >= 1400
if (0 != fopen_s(&f, filename, mode))
f=0;
#else
f = fopen(filename, mode);
#endif
return f;
}
STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
{
FILE *f = stbi__fopen(filename, "rb");
unsigned char *result;
if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
result = stbi_load_from_file(f,x,y,comp,req_comp);
fclose(f);
return result;
}
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
}
return result;
}
STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
{
stbi__uint16 *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
}
return result;
}
STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
{
FILE *f = stbi__fopen(filename, "rb");
stbi__uint16 *result;
if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
result = stbi_load_from_file_16(f,x,y,comp,req_comp);
fclose(f);
return result;
}
#endif //!STBI_NO_STDIO
STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
}
STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
}
STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
}
STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
}
#ifndef STBI_NO_GIF
STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_mem(&s,buffer,len);
result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
if (stbi__vertically_flip_on_load) {
stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
}
return result;
}
#endif
#ifndef STBI_NO_LINEAR
static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
unsigned char *data;
#ifndef STBI_NO_HDR
if (stbi__hdr_test(s)) {
stbi__result_info ri;
float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
if (hdr_data)
stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
return hdr_data;
}
#endif
data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
if (data)
return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
}
STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__loadf_main(&s,x,y,comp,req_comp);
}
STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
return stbi__loadf_main(&s,x,y,comp,req_comp);
}
#ifndef STBI_NO_STDIO
STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
{
float *result;
FILE *f = stbi__fopen(filename, "rb");
if (!f) return stbi__errpf("can't fopen", "Unable to open file");
result = stbi_loadf_from_file(f,x,y,comp,req_comp);
fclose(f);
return result;
}
STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_file(&s,f);
return stbi__loadf_main(&s,x,y,comp,req_comp);
}
#endif // !STBI_NO_STDIO
#endif // !STBI_NO_LINEAR
// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
// reports false!
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
{
#ifndef STBI_NO_HDR
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__hdr_test(&s);
#else
STBI_NOTUSED(buffer);
STBI_NOTUSED(len);
return 0;
#endif
}
#ifndef STBI_NO_STDIO
STBIDEF int stbi_is_hdr (char const *filename)
{
FILE *f = stbi__fopen(filename, "rb");
int result=0;
if (f) {
result = stbi_is_hdr_from_file(f);
fclose(f);
}
return result;
}
STBIDEF int stbi_is_hdr_from_file(FILE *f)
{
#ifndef STBI_NO_HDR
long pos = ftell(f);
int res;
stbi__context s;
stbi__start_file(&s,f);
res = stbi__hdr_test(&s);
fseek(f, pos, SEEK_SET);
return res;
#else
STBI_NOTUSED(f);
return 0;
#endif
}
#endif // !STBI_NO_STDIO
STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
{
#ifndef STBI_NO_HDR
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
return stbi__hdr_test(&s);
#else
STBI_NOTUSED(clbk);
STBI_NOTUSED(user);
return 0;
#endif
}
#ifndef STBI_NO_LINEAR
static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
#endif
static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
//////////////////////////////////////////////////////////////////////////////
//
// Common code used by all image loaders
//
enum
{
STBI__SCAN_load=0,
STBI__SCAN_type,
STBI__SCAN_header
};
static void stbi__refill_buffer(stbi__context *s)
{
int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
if (n == 0) {
// at end of file, treat same as if from memory, but need to handle case
// where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
s->read_from_callbacks = 0;
s->img_buffer = s->buffer_start;
s->img_buffer_end = s->buffer_start+1;
*s->img_buffer = 0;
} else {
s->img_buffer = s->buffer_start;
s->img_buffer_end = s->buffer_start + n;
}
}
stbi_inline static stbi_uc stbi__get8(stbi__context *s)
{
if (s->img_buffer < s->img_buffer_end)
return *s->img_buffer++;
if (s->read_from_callbacks) {
stbi__refill_buffer(s);
return *s->img_buffer++;
}
return 0;
}
#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
// nothing
#else
stbi_inline static int stbi__at_eof(stbi__context *s)
{
if (s->io.read) {
if (!(s->io.eof)(s->io_user_data)) return 0;
// if feof() is true, check if buffer = end
// special case: we've only got the special 0 character at the end
if (s->read_from_callbacks == 0) return 1;
}
return s->img_buffer >= s->img_buffer_end;
}
#endif
#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
// nothing
#else
static void stbi__skip(stbi__context *s, int n)
{
if (n == 0) return; // already there!
if (n < 0) {
s->img_buffer = s->img_buffer_end;
return;
}
if (s->io.read) {
int blen = (int) (s->img_buffer_end - s->img_buffer);
if (blen < n) {
s->img_buffer = s->img_buffer_end;
(s->io.skip)(s->io_user_data, n - blen);
return;
}
}
s->img_buffer += n;
}
#endif
#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
// nothing
#else
static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
{
if (s->io.read) {
int blen = (int) (s->img_buffer_end - s->img_buffer);
if (blen < n) {
int res, count;
memcpy(buffer, s->img_buffer, blen);
count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
res = (count == (n-blen));
s->img_buffer = s->img_buffer_end;
return res;
}
}
if (s->img_buffer+n <= s->img_buffer_end) {
memcpy(buffer, s->img_buffer, n);
s->img_buffer += n;
return 1;
} else
return 0;
}
#endif
#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
// nothing
#else
static int stbi__get16be(stbi__context *s)
{
int z = stbi__get8(s);
return (z << 8) + stbi__get8(s);
}
#endif
#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
// nothing
#else
static stbi__uint32 stbi__get32be(stbi__context *s)
{
stbi__uint32 z = stbi__get16be(s);
return (z << 16) + stbi__get16be(s);
}
#endif
#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
// nothing
#else
static int stbi__get16le(stbi__context *s)
{
int z = stbi__get8(s);
return z + (stbi__get8(s) << 8);
}
#endif
#ifndef STBI_NO_BMP
static stbi__uint32 stbi__get32le(stbi__context *s)
{
stbi__uint32 z = stbi__get16le(s);
return z + (stbi__get16le(s) << 16);
}
#endif
#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings
#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
// nothing
#else
//////////////////////////////////////////////////////////////////////////////
//
// generic converter from built-in img_n to req_comp
// individual types do this automatically as much as possible (e.g. jpeg
// does all cases internally since it needs to colorspace convert anyway,
// and it never has alpha, so very few cases ). png can automatically
// interleave an alpha=255 channel, but falls back to this for other cases
//
// assume data buffer is malloced, so malloc a new one and free that one
// only failure mode is malloc failing
static stbi_uc stbi__compute_y(int r, int g, int b)
{
return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);
}
#endif
#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
// nothing
#else
static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
{
int i,j;
unsigned char *good;
if (req_comp == img_n) return data;
STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
if (good == NULL) {
STBI_FREE(data);
return stbi__errpuc("outofmem", "Out of memory");
}
for (j=0; j < (int) y; ++j) {
unsigned char *src = data + j * x * img_n ;
unsigned char *dest = good + j * x * req_comp;
#define STBI__COMBO(a,b) ((a)*8+(b))
#define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
// convert source image with img_n components to one with req_comp components;
// avoid switch per pixel, so use switch per scanline and massive macros
switch (STBI__COMBO(img_n, req_comp)) {
STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;
STBI__CASE(2,1) { dest[0]=src[0]; } break;
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;
STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;
STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
}
#undef STBI__CASE
}
STBI_FREE(data);
return good;
}
#endif
#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
// nothing
#else
static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
{
return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);
}
#endif
#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
// nothing
#else
static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
{
int i,j;
stbi__uint16 *good;
if (req_comp == img_n) return data;
STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
if (good == NULL) {
STBI_FREE(data);
return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
}
for (j=0; j < (int) y; ++j) {
stbi__uint16 *src = data + j * x * img_n ;
stbi__uint16 *dest = good + j * x * req_comp;
#define STBI__COMBO(a,b) ((a)*8+(b))
#define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
// convert source image with img_n components to one with req_comp components;
// avoid switch per pixel, so use switch per scanline and massive macros
switch (STBI__COMBO(img_n, req_comp)) {
STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break;
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break;
STBI__CASE(2,1) { dest[0]=src[0]; } break;
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break;
STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
}
#undef STBI__CASE
}
STBI_FREE(data);
return good;
}
#endif
#ifndef STBI_NO_LINEAR
static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
{
int i,k,n;
float *output;
if (!data) return NULL;
output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
// compute number of non-alpha components
if (comp & 1) n = comp; else n = comp-1;
for (i=0; i < x*y; ++i) {
for (k=0; k < n; ++k) {
output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
}
}
if (n < comp) {
for (i=0; i < x*y; ++i) {
output[i*comp + n] = data[i*comp + n]/255.0f;
}
}
STBI_FREE(data);
return output;
}
#endif
#ifndef STBI_NO_HDR
#define stbi__float2int(x) ((int) (x))
static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)
{
int i,k,n;
stbi_uc *output;
if (!data) return NULL;
output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
// compute number of non-alpha components
if (comp & 1) n = comp; else n = comp-1;
for (i=0; i < x*y; ++i) {
for (k=0; k < n; ++k) {
float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
if (z < 0) z = 0;
if (z > 255) z = 255;
output[i*comp + k] = (stbi_uc) stbi__float2int(z);
}
if (k < comp) {
float z = data[i*comp+k] * 255 + 0.5f;
if (z < 0) z = 0;
if (z > 255) z = 255;
output[i*comp + k] = (stbi_uc) stbi__float2int(z);
}
}
STBI_FREE(data);
return output;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// "baseline" JPEG/JFIF decoder
//
// simple implementation
// - doesn't support delayed output of y-dimension
// - simple interface (only one output format: 8-bit interleaved RGB)
// - doesn't try to recover corrupt jpegs
// - doesn't allow partial loading, loading multiple at once
// - still fast on x86 (copying globals into locals doesn't help x86)
// - allocates lots of intermediate memory (full size of all components)
// - non-interleaved case requires this anyway
// - allows good upsampling (see next)
// high-quality
// - upsampled channels are bilinearly interpolated, even across blocks
// - quality integer IDCT derived from IJG's 'slow'
// performance
// - fast huffman; reasonable integer IDCT
// - some SIMD kernels for common paths on targets with SSE2/NEON
// - uses a lot of intermediate memory, could cache poorly
#ifndef STBI_NO_JPEG
// huffman decoding acceleration
#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
typedef struct
{
stbi_uc fast[1 << FAST_BITS];
// weirdly, repacking this into AoS is a 10% speed loss, instead of a win
stbi__uint16 code[256];
stbi_uc values[256];
stbi_uc size[257];
unsigned int maxcode[18];
int delta[17]; // old 'firstsymbol' - old 'firstcode'
} stbi__huffman;
typedef struct
{
stbi__context *s;
stbi__huffman huff_dc[4];
stbi__huffman huff_ac[4];
stbi__uint16 dequant[4][64];
stbi__int16 fast_ac[4][1 << FAST_BITS];
// sizes for components, interleaved MCUs
int img_h_max, img_v_max;
int img_mcu_x, img_mcu_y;
int img_mcu_w, img_mcu_h;
// definition of jpeg image component
struct
{
int id;
int h,v;
int tq;
int hd,ha;
int dc_pred;
int x,y,w2,h2;
stbi_uc *data;
void *raw_data, *raw_coeff;
stbi_uc *linebuf;
short *coeff; // progressive only
int coeff_w, coeff_h; // number of 8x8 coefficient blocks
} img_comp[4];
stbi__uint32 code_buffer; // jpeg entropy-coded buffer
int code_bits; // number of valid bits
unsigned char marker; // marker seen while filling entropy buffer
int nomore; // flag if we saw a marker so must stop
int progressive;
int spec_start;
int spec_end;
int succ_high;
int succ_low;
int eob_run;
int jfif;
int app14_color_transform; // Adobe APP14 tag
int rgb;
int scan_n, order[4];
int restart_interval, todo;
// kernels
void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
} stbi__jpeg;
static int stbi__build_huffman(stbi__huffman *h, int *count)
{
int i,j,k=0;
unsigned int code;
// build size list for each symbol (from JPEG spec)
for (i=0; i < 16; ++i)
for (j=0; j < count[i]; ++j)
h->size[k++] = (stbi_uc) (i+1);
h->size[k] = 0;
// compute actual symbols (from jpeg spec)
code = 0;
k = 0;
for(j=1; j <= 16; ++j) {
// compute delta to add to code to compute symbol id
h->delta[j] = k - code;
if (h->size[k] == j) {
while (h->size[k] == j)
h->code[k++] = (stbi__uint16) (code++);
if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
}
// compute largest code + 1 for this size, preshifted as needed later
h->maxcode[j] = code << (16-j);
code <<= 1;
}
h->maxcode[j] = 0xffffffff;
// build non-spec acceleration table; 255 is flag for not-accelerated
memset(h->fast, 255, 1 << FAST_BITS);
for (i=0; i < k; ++i) {
int s = h->size[i];
if (s <= FAST_BITS) {
int c = h->code[i] << (FAST_BITS-s);
int m = 1 << (FAST_BITS-s);
for (j=0; j < m; ++j) {
h->fast[c+j] = (stbi_uc) i;
}
}
}
return 1;
}
// build a table that decodes both magnitude and value of small ACs in
// one go.
static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
{
int i;
for (i=0; i < (1 << FAST_BITS); ++i) {
stbi_uc fast = h->fast[i];
fast_ac[i] = 0;
if (fast < 255) {
int rs = h->values[fast];
int run = (rs >> 4) & 15;
int magbits = rs & 15;
int len = h->size[fast];
if (magbits && len + magbits <= FAST_BITS) {
// magnitude code followed by receive_extend code
int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
int m = 1 << (magbits - 1);
if (k < m) k += (~0U << magbits) + 1;
// if the result is small enough, we can fit it in fast_ac table
if (k >= -128 && k <= 127)
fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
}
}
}
}
static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
{
do {
unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
if (b == 0xff) {
int c = stbi__get8(j->s);
while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
if (c != 0) {
j->marker = (unsigned char) c;
j->nomore = 1;
return;
}
}
j->code_buffer |= b << (24 - j->code_bits);
j->code_bits += 8;
} while (j->code_bits <= 24);
}
// (1 << n) - 1
static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
// decode a jpeg huffman value from the bitstream
stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
{
unsigned int temp;
int c,k;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
// look at the top FAST_BITS and determine what symbol ID it is,
// if the code is <= FAST_BITS
c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
k = h->fast[c];
if (k < 255) {
int s = h->size[k];
if (s > j->code_bits)
return -1;
j->code_buffer <<= s;
j->code_bits -= s;
return h->values[k];
}
// naive test is to shift the code_buffer down so k bits are
// valid, then test against maxcode. To speed this up, we've
// preshifted maxcode left so that it has (16-k) 0s at the
// end; in other words, regardless of the number of bits, it
// wants to be compared against something shifted to have 16;
// that way we don't need to shift inside the loop.
temp = j->code_buffer >> 16;
for (k=FAST_BITS+1 ; ; ++k)
if (temp < h->maxcode[k])
break;
if (k == 17) {
// error! code not found
j->code_bits -= 16;
return -1;
}
if (k > j->code_bits)
return -1;
// convert the huffman code to the symbol id
c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
// convert the id to a symbol
j->code_bits -= k;
j->code_buffer <<= k;
return h->values[c];
}
// bias[n] = (-1<<n) + 1
static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
// combined JPEG 'receive' and JPEG 'extend', since baseline
// always extends everything it receives.
stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
{
unsigned int k;
int sgn;
if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB
k = stbi_lrot(j->code_buffer, n);
if (n < 0 || n >= (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))) return 0;
j->code_buffer = k & ~stbi__bmask[n];
k &= stbi__bmask[n];
j->code_bits -= n;
return k + (stbi__jbias[n] & ~sgn);
}
// get some unsigned bits
stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
{
unsigned int k;
if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
k = stbi_lrot(j->code_buffer, n);
j->code_buffer = k & ~stbi__bmask[n];
k &= stbi__bmask[n];
j->code_bits -= n;
return k;
}
stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
{
unsigned int k;
if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
k = j->code_buffer;
j->code_buffer <<= 1;
--j->code_bits;
return k & 0x80000000;
}
// given a value that's at position X in the zigzag stream,
// where does it appear in the 8x8 matrix coded as row-major?
static const stbi_uc stbi__jpeg_dezigzag[64+15] =
{
0, 1, 8, 16, 9, 2, 3, 10,
17, 24, 32, 25, 18, 11, 4, 5,
12, 19, 26, 33, 40, 48, 41, 34,
27, 20, 13, 6, 7, 14, 21, 28,
35, 42, 49, 56, 57, 50, 43, 36,
29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46,
53, 60, 61, 54, 47, 55, 62, 63,
// let corrupt input sample past end
63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63
};
// decode one 64-entry block--
static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
{
int diff,dc,k;
int t;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
t = stbi__jpeg_huff_decode(j, hdc);
if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG");
// 0 all the ac values now so we can do it 32-bits at a time
memset(data,0,64*sizeof(data[0]));
diff = t ? stbi__extend_receive(j, t) : 0;
dc = j->img_comp[b].dc_pred + diff;
j->img_comp[b].dc_pred = dc;
data[0] = (short) (dc * dequant[0]);
// decode AC components, see JPEG spec
k = 1;
do {
unsigned int zig;
int c,r,s;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
r = fac[c];
if (r) { // fast-AC path
k += (r >> 4) & 15; // run
s = r & 15; // combined length
j->code_buffer <<= s;
j->code_bits -= s;
// decode into unzigzag'd location
zig = stbi__jpeg_dezigzag[k++];
data[zig] = (short) ((r >> 8) * dequant[zig]);
} else {
int rs = stbi__jpeg_huff_decode(j, hac);
if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
s = rs & 15;
r = rs >> 4;
if (s == 0) {
if (rs != 0xf0) break; // end block
k += 16;
} else {
k += r;
// decode into unzigzag'd location
zig = stbi__jpeg_dezigzag[k++];
data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
}
}
} while (k < 64);
return 1;
}
static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
{
int diff,dc;
int t;
if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
if (j->succ_high == 0) {
// first scan for DC coefficient, must be first
memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
t = stbi__jpeg_huff_decode(j, hdc);
if (t == -1) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
diff = t ? stbi__extend_receive(j, t) : 0;
dc = j->img_comp[b].dc_pred + diff;
j->img_comp[b].dc_pred = dc;
data[0] = (short) (dc << j->succ_low);
} else {
// refinement scan for DC coefficient
if (stbi__jpeg_get_bit(j))
data[0] += (short) (1 << j->succ_low);
}
return 1;
}
// @OPTIMIZE: store non-zigzagged during the decode passes,
// and only de-zigzag when dequantizing
static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
{
int k;
if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
if (j->succ_high == 0) {
int shift = j->succ_low;
if (j->eob_run) {
--j->eob_run;
return 1;
}
k = j->spec_start;
do {
unsigned int zig;
int c,r,s;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
r = fac[c];
if (r) { // fast-AC path
k += (r >> 4) & 15; // run
s = r & 15; // combined length
j->code_buffer <<= s;
j->code_bits -= s;
zig = stbi__jpeg_dezigzag[k++];
data[zig] = (short) ((r >> 8) << shift);
} else {
int rs = stbi__jpeg_huff_decode(j, hac);
if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
s = rs & 15;
r = rs >> 4;
if (s == 0) {
if (r < 15) {
j->eob_run = (1 << r);
if (r)
j->eob_run += stbi__jpeg_get_bits(j, r);
--j->eob_run;
break;
}
k += 16;
} else {
k += r;
zig = stbi__jpeg_dezigzag[k++];
data[zig] = (short) (stbi__extend_receive(j,s) << shift);
}
}
} while (k <= j->spec_end);
} else {
// refinement scan for these AC coefficients
short bit = (short) (1 << j->succ_low);
if (j->eob_run) {
--j->eob_run;
for (k = j->spec_start; k <= j->spec_end; ++k) {
short *p = &data[stbi__jpeg_dezigzag[k]];
if (*p != 0)
if (stbi__jpeg_get_bit(j))
if ((*p & bit)==0) {
if (*p > 0)
*p += bit;
else
*p -= bit;
}
}
} else {
k = j->spec_start;
do {
int r,s;
int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
s = rs & 15;
r = rs >> 4;
if (s == 0) {
if (r < 15) {
j->eob_run = (1 << r) - 1;
if (r)
j->eob_run += stbi__jpeg_get_bits(j, r);
r = 64; // force end of block
} else {
// r=15 s=0 should write 16 0s, so we just do
// a run of 15 0s and then write s (which is 0),
// so we don't have to do anything special here
}
} else {
if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
// sign bit
if (stbi__jpeg_get_bit(j))
s = bit;
else
s = -bit;
}
// advance by r
while (k <= j->spec_end) {
short *p = &data[stbi__jpeg_dezigzag[k++]];
if (*p != 0) {
if (stbi__jpeg_get_bit(j))
if ((*p & bit)==0) {
if (*p > 0)
*p += bit;
else
*p -= bit;
}
} else {
if (r == 0) {
*p = (short) s;
break;
}
--r;
}
}
} while (k <= j->spec_end);
}
}
return 1;
}
// take a -128..127 value and stbi__clamp it and convert to 0..255
stbi_inline static stbi_uc stbi__clamp(int x)
{
// trick to use a single test to catch both cases
if ((unsigned int) x > 255) {
if (x < 0) return 0;
if (x > 255) return 255;
}
return (stbi_uc) x;
}
#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))
#define stbi__fsh(x) ((x) * 4096)
// derived from jidctint -- DCT_ISLOW
#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
p2 = s2; \
p3 = s6; \
p1 = (p2+p3) * stbi__f2f(0.5411961f); \
t2 = p1 + p3*stbi__f2f(-1.847759065f); \
t3 = p1 + p2*stbi__f2f( 0.765366865f); \
p2 = s0; \
p3 = s4; \
t0 = stbi__fsh(p2+p3); \
t1 = stbi__fsh(p2-p3); \
x0 = t0+t3; \
x3 = t0-t3; \
x1 = t1+t2; \
x2 = t1-t2; \
t0 = s7; \
t1 = s5; \
t2 = s3; \
t3 = s1; \
p3 = t0+t2; \
p4 = t1+t3; \
p1 = t0+t3; \
p2 = t1+t2; \
p5 = (p3+p4)*stbi__f2f( 1.175875602f); \
t0 = t0*stbi__f2f( 0.298631336f); \
t1 = t1*stbi__f2f( 2.053119869f); \
t2 = t2*stbi__f2f( 3.072711026f); \
t3 = t3*stbi__f2f( 1.501321110f); \
p1 = p5 + p1*stbi__f2f(-0.899976223f); \
p2 = p5 + p2*stbi__f2f(-2.562915447f); \
p3 = p3*stbi__f2f(-1.961570560f); \
p4 = p4*stbi__f2f(-0.390180644f); \
t3 += p1+p4; \
t2 += p2+p3; \
t1 += p2+p4; \
t0 += p1+p3;
static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
{
int i,val[64],*v=val;
stbi_uc *o;
short *d = data;
// columns
for (i=0; i < 8; ++i,++d, ++v) {
// if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
&& d[40]==0 && d[48]==0 && d[56]==0) {
// no shortcut 0 seconds
// (1|2|3|4|5|6|7)==0 0 seconds
// all separate -0.047 seconds
// 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
int dcterm = d[0]*4;
v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
} else {
STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
// constants scaled things up by 1<<12; let's bring them back
// down, but keep 2 extra bits of precision
x0 += 512; x1 += 512; x2 += 512; x3 += 512;
v[ 0] = (x0+t3) >> 10;
v[56] = (x0-t3) >> 10;
v[ 8] = (x1+t2) >> 10;
v[48] = (x1-t2) >> 10;
v[16] = (x2+t1) >> 10;
v[40] = (x2-t1) >> 10;
v[24] = (x3+t0) >> 10;
v[32] = (x3-t0) >> 10;
}
}
for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
// no fast case since the first 1D IDCT spread components out
STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
// constants scaled things up by 1<<12, plus we had 1<<2 from first
// loop, plus horizontal and vertical each scale by sqrt(8) so together
// we've got an extra 1<<3, so 1<<17 total we need to remove.
// so we want to round that, which means adding 0.5 * 1<<17,
// aka 65536. Also, we'll end up with -128 to 127 that we want
// to encode as 0..255 by adding 128, so we'll add that before the shift
x0 += 65536 + (128<<17);
x1 += 65536 + (128<<17);
x2 += 65536 + (128<<17);
x3 += 65536 + (128<<17);
// tried computing the shifts into temps, or'ing the temps to see
// if any were out of range, but that was slower
o[0] = stbi__clamp((x0+t3) >> 17);
o[7] = stbi__clamp((x0-t3) >> 17);
o[1] = stbi__clamp((x1+t2) >> 17);
o[6] = stbi__clamp((x1-t2) >> 17);
o[2] = stbi__clamp((x2+t1) >> 17);
o[5] = stbi__clamp((x2-t1) >> 17);
o[3] = stbi__clamp((x3+t0) >> 17);
o[4] = stbi__clamp((x3-t0) >> 17);
}
}
#ifdef STBI_SSE2
// sse2 integer IDCT. not the fastest possible implementation but it
// produces bit-identical results to the generic C version so it's
// fully "transparent".
static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
{
// This is constructed to match our regular (generic) integer IDCT exactly.
__m128i row0, row1, row2, row3, row4, row5, row6, row7;
__m128i tmp;
// dot product constant: even elems=x, odd elems=y
#define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
// out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit)
// out(1) = c1[even]*x + c1[odd]*y
#define dct_rot(out0,out1, x,y,c0,c1) \
__m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
__m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
__m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
__m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
__m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
__m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
// out = in << 12 (in 16-bit, out 32-bit)
#define dct_widen(out, in) \
__m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
__m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
// wide add
#define dct_wadd(out, a, b) \
__m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
__m128i out##_h = _mm_add_epi32(a##_h, b##_h)
// wide sub
#define dct_wsub(out, a, b) \
__m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
__m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
// butterfly a/b, add bias, then shift by "s" and pack
#define dct_bfly32o(out0, out1, a,b,bias,s) \
{ \
__m128i abiased_l = _mm_add_epi32(a##_l, bias); \
__m128i abiased_h = _mm_add_epi32(a##_h, bias); \
dct_wadd(sum, abiased, b); \
dct_wsub(dif, abiased, b); \
out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
}
// 8-bit interleave step (for transposes)
#define dct_interleave8(a, b) \
tmp = a; \
a = _mm_unpacklo_epi8(a, b); \
b = _mm_unpackhi_epi8(tmp, b)
// 16-bit interleave step (for transposes)
#define dct_interleave16(a, b) \
tmp = a; \
a = _mm_unpacklo_epi16(a, b); \
b = _mm_unpackhi_epi16(tmp, b)
#define dct_pass(bias,shift) \
{ \
/* even part */ \
dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
__m128i sum04 = _mm_add_epi16(row0, row4); \
__m128i dif04 = _mm_sub_epi16(row0, row4); \
dct_widen(t0e, sum04); \
dct_widen(t1e, dif04); \
dct_wadd(x0, t0e, t3e); \
dct_wsub(x3, t0e, t3e); \
dct_wadd(x1, t1e, t2e); \
dct_wsub(x2, t1e, t2e); \
/* odd part */ \
dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
__m128i sum17 = _mm_add_epi16(row1, row7); \
__m128i sum35 = _mm_add_epi16(row3, row5); \
dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
dct_wadd(x4, y0o, y4o); \
dct_wadd(x5, y1o, y5o); \
dct_wadd(x6, y2o, y5o); \
dct_wadd(x7, y3o, y4o); \
dct_bfly32o(row0,row7, x0,x7,bias,shift); \
dct_bfly32o(row1,row6, x1,x6,bias,shift); \
dct_bfly32o(row2,row5, x2,x5,bias,shift); \
dct_bfly32o(row3,row4, x3,x4,bias,shift); \
}
__m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
__m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
__m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
__m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
__m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
__m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
__m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
__m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
// rounding biases in column/row passes, see stbi__idct_block for explanation.
__m128i bias_0 = _mm_set1_epi32(512);
__m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
// load
row0 = _mm_load_si128((const __m128i *) (data + 0*8));
row1 = _mm_load_si128((const __m128i *) (data + 1*8));
row2 = _mm_load_si128((const __m128i *) (data + 2*8));
row3 = _mm_load_si128((const __m128i *) (data + 3*8));
row4 = _mm_load_si128((const __m128i *) (data + 4*8));
row5 = _mm_load_si128((const __m128i *) (data + 5*8));
row6 = _mm_load_si128((const __m128i *) (data + 6*8));
row7 = _mm_load_si128((const __m128i *) (data + 7*8));
// column pass
dct_pass(bias_0, 10);
{
// 16bit 8x8 transpose pass 1
dct_interleave16(row0, row4);
dct_interleave16(row1, row5);
dct_interleave16(row2, row6);
dct_interleave16(row3, row7);
// transpose pass 2
dct_interleave16(row0, row2);
dct_interleave16(row1, row3);
dct_interleave16(row4, row6);
dct_interleave16(row5, row7);
// transpose pass 3
dct_interleave16(row0, row1);
dct_interleave16(row2, row3);
dct_interleave16(row4, row5);
dct_interleave16(row6, row7);
}
// row pass
dct_pass(bias_1, 17);
{
// pack
__m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
__m128i p1 = _mm_packus_epi16(row2, row3);
__m128i p2 = _mm_packus_epi16(row4, row5);
__m128i p3 = _mm_packus_epi16(row6, row7);
// 8bit 8x8 transpose pass 1
dct_interleave8(p0, p2); // a0e0a1e1...
dct_interleave8(p1, p3); // c0g0c1g1...
// transpose pass 2
dct_interleave8(p0, p1); // a0c0e0g0...
dct_interleave8(p2, p3); // b0d0f0h0...
// transpose pass 3
dct_interleave8(p0, p2); // a0b0c0d0...
dct_interleave8(p1, p3); // a4b4c4d4...
// store
_mm_storel_epi64((__m128i *) out, p0); out += out_stride;
_mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
_mm_storel_epi64((__m128i *) out, p2); out += out_stride;
_mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
_mm_storel_epi64((__m128i *) out, p1); out += out_stride;
_mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
_mm_storel_epi64((__m128i *) out, p3); out += out_stride;
_mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
}
#undef dct_const
#undef dct_rot
#undef dct_widen
#undef dct_wadd
#undef dct_wsub
#undef dct_bfly32o
#undef dct_interleave8
#undef dct_interleave16
#undef dct_pass
}
#endif // STBI_SSE2
#ifdef STBI_NEON
// NEON integer IDCT. should produce bit-identical
// results to the generic C version.
static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
{
int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
#define dct_long_mul(out, inq, coeff) \
int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
#define dct_long_mac(out, acc, inq, coeff) \
int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
#define dct_widen(out, inq) \
int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
// wide add
#define dct_wadd(out, a, b) \
int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
// wide sub
#define dct_wsub(out, a, b) \
int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
// butterfly a/b, then shift using "shiftop" by "s" and pack
#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
{ \
dct_wadd(sum, a, b); \
dct_wsub(dif, a, b); \
out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
}
#define dct_pass(shiftop, shift) \
{ \
/* even part */ \
int16x8_t sum26 = vaddq_s16(row2, row6); \
dct_long_mul(p1e, sum26, rot0_0); \
dct_long_mac(t2e, p1e, row6, rot0_1); \
dct_long_mac(t3e, p1e, row2, rot0_2); \
int16x8_t sum04 = vaddq_s16(row0, row4); \
int16x8_t dif04 = vsubq_s16(row0, row4); \
dct_widen(t0e, sum04); \
dct_widen(t1e, dif04); \
dct_wadd(x0, t0e, t3e); \
dct_wsub(x3, t0e, t3e); \
dct_wadd(x1, t1e, t2e); \
dct_wsub(x2, t1e, t2e); \
/* odd part */ \
int16x8_t sum15 = vaddq_s16(row1, row5); \
int16x8_t sum17 = vaddq_s16(row1, row7); \
int16x8_t sum35 = vaddq_s16(row3, row5); \
int16x8_t sum37 = vaddq_s16(row3, row7); \
int16x8_t sumodd = vaddq_s16(sum17, sum35); \
dct_long_mul(p5o, sumodd, rot1_0); \
dct_long_mac(p1o, p5o, sum17, rot1_1); \
dct_long_mac(p2o, p5o, sum35, rot1_2); \
dct_long_mul(p3o, sum37, rot2_0); \
dct_long_mul(p4o, sum15, rot2_1); \
dct_wadd(sump13o, p1o, p3o); \
dct_wadd(sump24o, p2o, p4o); \
dct_wadd(sump23o, p2o, p3o); \
dct_wadd(sump14o, p1o, p4o); \
dct_long_mac(x4, sump13o, row7, rot3_0); \
dct_long_mac(x5, sump24o, row5, rot3_1); \
dct_long_mac(x6, sump23o, row3, rot3_2); \
dct_long_mac(x7, sump14o, row1, rot3_3); \
dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
}
// load
row0 = vld1q_s16(data + 0*8);
row1 = vld1q_s16(data + 1*8);
row2 = vld1q_s16(data + 2*8);
row3 = vld1q_s16(data + 3*8);
row4 = vld1q_s16(data + 4*8);
row5 = vld1q_s16(data + 5*8);
row6 = vld1q_s16(data + 6*8);
row7 = vld1q_s16(data + 7*8);
// add DC bias
row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
// column pass
dct_pass(vrshrn_n_s32, 10);
// 16bit 8x8 transpose
{
// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
// whether compilers actually get this is another story, sadly.
#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
// pass 1
dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
dct_trn16(row2, row3);
dct_trn16(row4, row5);
dct_trn16(row6, row7);
// pass 2
dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
dct_trn32(row1, row3);
dct_trn32(row4, row6);
dct_trn32(row5, row7);
// pass 3
dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
dct_trn64(row1, row5);
dct_trn64(row2, row6);
dct_trn64(row3, row7);
#undef dct_trn16
#undef dct_trn32
#undef dct_trn64
}
// row pass
// vrshrn_n_s32 only supports shifts up to 16, we need
// 17. so do a non-rounding shift of 16 first then follow
// up with a rounding shift by 1.
dct_pass(vshrn_n_s32, 16);
{
// pack and round
uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
// again, these can translate into one instruction, but often don't.
#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
// sadly can't use interleaved stores here since we only write
// 8 bytes to each scan line!
// 8x8 8-bit transpose pass 1
dct_trn8_8(p0, p1);
dct_trn8_8(p2, p3);
dct_trn8_8(p4, p5);
dct_trn8_8(p6, p7);
// pass 2
dct_trn8_16(p0, p2);
dct_trn8_16(p1, p3);
dct_trn8_16(p4, p6);
dct_trn8_16(p5, p7);
// pass 3
dct_trn8_32(p0, p4);
dct_trn8_32(p1, p5);
dct_trn8_32(p2, p6);
dct_trn8_32(p3, p7);
// store
vst1_u8(out, p0); out += out_stride;
vst1_u8(out, p1); out += out_stride;
vst1_u8(out, p2); out += out_stride;
vst1_u8(out, p3); out += out_stride;
vst1_u8(out, p4); out += out_stride;
vst1_u8(out, p5); out += out_stride;
vst1_u8(out, p6); out += out_stride;
vst1_u8(out, p7);
#undef dct_trn8_8
#undef dct_trn8_16
#undef dct_trn8_32
}
#undef dct_long_mul
#undef dct_long_mac
#undef dct_widen
#undef dct_wadd
#undef dct_wsub
#undef dct_bfly32o
#undef dct_pass
}
#endif // STBI_NEON
#define STBI__MARKER_none 0xff
// if there's a pending marker from the entropy stream, return that
// otherwise, fetch from the stream and get a marker. if there's no
// marker, return 0xff, which is never a valid marker value
static stbi_uc stbi__get_marker(stbi__jpeg *j)
{
stbi_uc x;
if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
x = stbi__get8(j->s);
if (x != 0xff) return STBI__MARKER_none;
while (x == 0xff)
x = stbi__get8(j->s); // consume repeated 0xff fill bytes
return x;
}
// in each scan, we'll have scan_n components, and the order
// of the components is specified by order[]
#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
// after a restart interval, stbi__jpeg_reset the entropy decoder and
// the dc prediction
static void stbi__jpeg_reset(stbi__jpeg *j)
{
j->code_bits = 0;
j->code_buffer = 0;
j->nomore = 0;
j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
j->marker = STBI__MARKER_none;
j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
j->eob_run = 0;
// no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
// since we don't even allow 1<<30 pixels
}
static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
{
stbi__jpeg_reset(z);
if (!z->progressive) {
if (z->scan_n == 1) {
int i,j;
STBI_SIMD_ALIGN(short, data[64]);
int n = z->order[0];
// non-interleaved data, we just need to process one block at a time,
// in trivial scanline order
// number of blocks to do just depends on how many actual "pixels" this
// component has, independent of interleaved MCU blocking and such
int w = (z->img_comp[n].x+7) >> 3;
int h = (z->img_comp[n].y+7) >> 3;
for (j=0; j < h; ++j) {
for (i=0; i < w; ++i) {
int ha = z->img_comp[n].ha;
if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
// every data block is an MCU, so countdown the restart interval
if (--z->todo <= 0) {
if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
// if it's NOT a restart, then just bail, so we get corrupt data
// rather than no data
if (!STBI__RESTART(z->marker)) return 1;
stbi__jpeg_reset(z);
}
}
}
return 1;
} else { // interleaved
int i,j,k,x,y;
STBI_SIMD_ALIGN(short, data[64]);
for (j=0; j < z->img_mcu_y; ++j) {
for (i=0; i < z->img_mcu_x; ++i) {
// scan an interleaved mcu... process scan_n components in order
for (k=0; k < z->scan_n; ++k) {
int n = z->order[k];
// scan out an mcu's worth of this component; that's just determined
// by the basic H and V specified for the component
for (y=0; y < z->img_comp[n].v; ++y) {
for (x=0; x < z->img_comp[n].h; ++x) {
int x2 = (i*z->img_comp[n].h + x)*8;
int y2 = (j*z->img_comp[n].v + y)*8;
int ha = z->img_comp[n].ha;
if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
}
}
}
// after all interleaved components, that's an interleaved MCU,
// so now count down the restart interval
if (--z->todo <= 0) {
if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
if (!STBI__RESTART(z->marker)) return 1;
stbi__jpeg_reset(z);
}
}
}
return 1;
}
} else {
if (z->scan_n == 1) {
int i,j;
int n = z->order[0];
// non-interleaved data, we just need to process one block at a time,
// in trivial scanline order
// number of blocks to do just depends on how many actual "pixels" this
// component has, independent of interleaved MCU blocking and such
int w = (z->img_comp[n].x+7) >> 3;
int h = (z->img_comp[n].y+7) >> 3;
for (j=0; j < h; ++j) {
for (i=0; i < w; ++i) {
short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
if (z->spec_start == 0) {
if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
return 0;
} else {
int ha = z->img_comp[n].ha;
if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
return 0;
}
// every data block is an MCU, so countdown the restart interval
if (--z->todo <= 0) {
if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
if (!STBI__RESTART(z->marker)) return 1;
stbi__jpeg_reset(z);
}
}
}
return 1;
} else { // interleaved
int i,j,k,x,y;
for (j=0; j < z->img_mcu_y; ++j) {
for (i=0; i < z->img_mcu_x; ++i) {
// scan an interleaved mcu... process scan_n components in order
for (k=0; k < z->scan_n; ++k) {
int n = z->order[k];
// scan out an mcu's worth of this component; that's just determined
// by the basic H and V specified for the component
for (y=0; y < z->img_comp[n].v; ++y) {
for (x=0; x < z->img_comp[n].h; ++x) {
int x2 = (i*z->img_comp[n].h + x);
int y2 = (j*z->img_comp[n].v + y);
short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
return 0;
}
}
}
// after all interleaved components, that's an interleaved MCU,
// so now count down the restart interval
if (--z->todo <= 0) {
if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
if (!STBI__RESTART(z->marker)) return 1;
stbi__jpeg_reset(z);
}
}
}
return 1;
}
}
}
static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
{
int i;
for (i=0; i < 64; ++i)
data[i] *= dequant[i];
}
static void stbi__jpeg_finish(stbi__jpeg *z)
{
if (z->progressive) {
// dequantize and idct the data
int i,j,n;
for (n=0; n < z->s->img_n; ++n) {
int w = (z->img_comp[n].x+7) >> 3;
int h = (z->img_comp[n].y+7) >> 3;
for (j=0; j < h; ++j) {
for (i=0; i < w; ++i) {
short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
}
}
}
}
}
static int stbi__process_marker(stbi__jpeg *z, int m)
{
int L;
switch (m) {
case STBI__MARKER_none: // no marker found
return stbi__err("expected marker","Corrupt JPEG");
case 0xDD: // DRI - specify restart interval
if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
z->restart_interval = stbi__get16be(z->s);
return 1;
case 0xDB: // DQT - define quantization table
L = stbi__get16be(z->s)-2;
while (L > 0) {
int q = stbi__get8(z->s);
int p = q >> 4, sixteen = (p != 0);
int t = q & 15,i;
if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
for (i=0; i < 64; ++i)
z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
L -= (sixteen ? 129 : 65);
}
return L==0;
case 0xC4: // DHT - define huffman table
L = stbi__get16be(z->s)-2;
while (L > 0) {
stbi_uc *v;
int sizes[16],i,n=0;
int q = stbi__get8(z->s);
int tc = q >> 4;
int th = q & 15;
if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
for (i=0; i < 16; ++i) {
sizes[i] = stbi__get8(z->s);
n += sizes[i];
}
L -= 17;
if (tc == 0) {
if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
v = z->huff_dc[th].values;
} else {
if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
v = z->huff_ac[th].values;
}
for (i=0; i < n; ++i)
v[i] = stbi__get8(z->s);
if (tc != 0)
stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
L -= n;
}
return L==0;
}
// check for comment block or APP blocks
if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
L = stbi__get16be(z->s);
if (L < 2) {
if (m == 0xFE)
return stbi__err("bad COM len","Corrupt JPEG");
else
return stbi__err("bad APP len","Corrupt JPEG");
}
L -= 2;
if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
static const unsigned char tag[5] = {'J','F','I','F','\0'};
int ok = 1;
int i;
for (i=0; i < 5; ++i)
if (stbi__get8(z->s) != tag[i])
ok = 0;
L -= 5;
if (ok)
z->jfif = 1;
} else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
int ok = 1;
int i;
for (i=0; i < 6; ++i)
if (stbi__get8(z->s) != tag[i])
ok = 0;
L -= 6;
if (ok) {
stbi__get8(z->s); // version
stbi__get16be(z->s); // flags0
stbi__get16be(z->s); // flags1
z->app14_color_transform = stbi__get8(z->s); // color transform
L -= 6;
}
}
stbi__skip(z->s, L);
return 1;
}
return stbi__err("unknown marker","Corrupt JPEG");
}
// after we see SOS
static int stbi__process_scan_header(stbi__jpeg *z)
{
int i;
int Ls = stbi__get16be(z->s);
z->scan_n = stbi__get8(z->s);
if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
for (i=0; i < z->scan_n; ++i) {
int id = stbi__get8(z->s), which;
int q = stbi__get8(z->s);
for (which = 0; which < z->s->img_n; ++which)
if (z->img_comp[which].id == id)
break;
if (which == z->s->img_n) return 0; // no match
z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
z->order[i] = which;
}
{
int aa;
z->spec_start = stbi__get8(z->s);
z->spec_end = stbi__get8(z->s); // should be 63, but might be 0
aa = stbi__get8(z->s);
z->succ_high = (aa >> 4);
z->succ_low = (aa & 15);
if (z->progressive) {
if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
return stbi__err("bad SOS", "Corrupt JPEG");
} else {
if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
z->spec_end = 63;
}
}
return 1;
}
static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
{
int i;
for (i=0; i < ncomp; ++i) {
if (z->img_comp[i].raw_data) {
STBI_FREE(z->img_comp[i].raw_data);
z->img_comp[i].raw_data = NULL;
z->img_comp[i].data = NULL;
}
if (z->img_comp[i].raw_coeff) {
STBI_FREE(z->img_comp[i].raw_coeff);
z->img_comp[i].raw_coeff = 0;
z->img_comp[i].coeff = 0;
}
if (z->img_comp[i].linebuf) {
STBI_FREE(z->img_comp[i].linebuf);
z->img_comp[i].linebuf = NULL;
}
}
return why;
}
static int stbi__process_frame_header(stbi__jpeg *z, int scan)
{
stbi__context *s = z->s;
int Lf,p,i,q, h_max=1,v_max=1,c;
Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
c = stbi__get8(s);
if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
s->img_n = c;
for (i=0; i < c; ++i) {
z->img_comp[i].data = NULL;
z->img_comp[i].linebuf = NULL;
}
if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
z->rgb = 0;
for (i=0; i < s->img_n; ++i) {
static const unsigned char rgb[3] = { 'R', 'G', 'B' };
z->img_comp[i].id = stbi__get8(s);
if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
++z->rgb;
q = stbi__get8(s);
z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
}
if (scan != STBI__SCAN_load) return 1;
if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
for (i=0; i < s->img_n; ++i) {
if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
}
// compute interleaved mcu info
z->img_h_max = h_max;
z->img_v_max = v_max;
z->img_mcu_w = h_max * 8;
z->img_mcu_h = v_max * 8;
// these sizes can't be more than 17 bits
z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
for (i=0; i < s->img_n; ++i) {
// number of effective pixels (e.g. for non-interleaved MCU)
z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
// to simplify generation, we'll allocate enough memory to decode
// the bogus oversized data from using interleaved MCUs and their
// big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
// discard the extra data until colorspace conversion
//
// img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
// so these muls can't overflow with 32-bit ints (which we require)
z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
z->img_comp[i].coeff = 0;
z->img_comp[i].raw_coeff = 0;
z->img_comp[i].linebuf = NULL;
z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
if (z->img_comp[i].raw_data == NULL)
return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
// align blocks for idct using mmx/sse
z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
if (z->progressive) {
// w2, h2 are multiples of 8 (see above)
z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
if (z->img_comp[i].raw_coeff == NULL)
return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
}
}
return 1;
}
// use comparisons since in some cases we handle more than one case (e.g. SOF)
#define stbi__DNL(x) ((x) == 0xdc)
#define stbi__SOI(x) ((x) == 0xd8)
#define stbi__EOI(x) ((x) == 0xd9)
#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
#define stbi__SOS(x) ((x) == 0xda)
#define stbi__SOF_progressive(x) ((x) == 0xc2)
static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
{
int m;
z->jfif = 0;
z->app14_color_transform = -1; // valid values are 0,1,2
z->marker = STBI__MARKER_none; // initialize cached marker to empty
m = stbi__get_marker(z);
if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
if (scan == STBI__SCAN_type) return 1;
m = stbi__get_marker(z);
while (!stbi__SOF(m)) {
if (!stbi__process_marker(z,m)) return 0;
m = stbi__get_marker(z);
while (m == STBI__MARKER_none) {
// some files have extra padding after their blocks, so ok, we'll scan
if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
m = stbi__get_marker(z);
}
}
z->progressive = stbi__SOF_progressive(m);
if (!stbi__process_frame_header(z, scan)) return 0;
return 1;
}
// decode image to YCbCr format
static int stbi__decode_jpeg_image(stbi__jpeg *j)
{
int m;
for (m = 0; m < 4; m++) {
j->img_comp[m].raw_data = NULL;
j->img_comp[m].raw_coeff = NULL;
}
j->restart_interval = 0;
if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
m = stbi__get_marker(j);
while (!stbi__EOI(m)) {
if (stbi__SOS(m)) {
if (!stbi__process_scan_header(j)) return 0;
if (!stbi__parse_entropy_coded_data(j)) return 0;
if (j->marker == STBI__MARKER_none ) {
// handle 0s at the end of image data from IP Kamera 9060
while (!stbi__at_eof(j->s)) {
int x = stbi__get8(j->s);
if (x == 255) {
j->marker = stbi__get8(j->s);
break;
}
}
// if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
}
} else if (stbi__DNL(m)) {
int Ld = stbi__get16be(j->s);
stbi__uint32 NL = stbi__get16be(j->s);
if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
} else {
if (!stbi__process_marker(j, m)) return 0;
}
m = stbi__get_marker(j);
}
if (j->progressive)
stbi__jpeg_finish(j);
return 1;
}
// static jfif-centered resampling (across block boundaries)
typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
int w, int hs);
#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
STBI_NOTUSED(out);
STBI_NOTUSED(in_far);
STBI_NOTUSED(w);
STBI_NOTUSED(hs);
return in_near;
}
static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate two samples vertically for every one in input
int i;
STBI_NOTUSED(hs);
for (i=0; i < w; ++i)
out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
return out;
}
static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate two samples horizontally for every one in input
int i;
stbi_uc *input = in_near;
if (w == 1) {
// if only one sample, can't do any interpolation
out[0] = out[1] = input[0];
return out;
}
out[0] = input[0];
out[1] = stbi__div4(input[0]*3 + input[1] + 2);
for (i=1; i < w-1; ++i) {
int n = 3*input[i]+2;
out[i*2+0] = stbi__div4(n+input[i-1]);
out[i*2+1] = stbi__div4(n+input[i+1]);
}
out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
out[i*2+1] = input[w-1];
STBI_NOTUSED(in_far);
STBI_NOTUSED(hs);
return out;
}
#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate 2x2 samples for every one in input
int i,t0,t1;
if (w == 1) {
out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
return out;
}
t1 = 3*in_near[0] + in_far[0];
out[0] = stbi__div4(t1+2);
for (i=1; i < w; ++i) {
t0 = t1;
t1 = 3*in_near[i]+in_far[i];
out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
}
out[w*2-1] = stbi__div4(t1+2);
STBI_NOTUSED(hs);
return out;
}
#if defined(STBI_SSE2) || defined(STBI_NEON)
static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate 2x2 samples for every one in input
int i=0,t0,t1;
if (w == 1) {
out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
return out;
}
t1 = 3*in_near[0] + in_far[0];
// process groups of 8 pixels for as long as we can.
// note we can't handle the last pixel in a row in this loop
// because we need to handle the filter boundary conditions.
for (; i < ((w-1) & ~7); i += 8) {
#if defined(STBI_SSE2)
// load and perform the vertical filtering pass
// this uses 3*x + y = 4*x + (y - x)
__m128i zero = _mm_setzero_si128();
__m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));
__m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
__m128i farw = _mm_unpacklo_epi8(farb, zero);
__m128i nearw = _mm_unpacklo_epi8(nearb, zero);
__m128i diff = _mm_sub_epi16(farw, nearw);
__m128i nears = _mm_slli_epi16(nearw, 2);
__m128i curr = _mm_add_epi16(nears, diff); // current row
// horizontal filter works the same based on shifted vers of current
// row. "prev" is current row shifted right by 1 pixel; we need to
// insert the previous pixel value (from t1).
// "next" is current row shifted left by 1 pixel, with first pixel
// of next block of 8 pixels added in.
__m128i prv0 = _mm_slli_si128(curr, 2);
__m128i nxt0 = _mm_srli_si128(curr, 2);
__m128i prev = _mm_insert_epi16(prv0, t1, 0);
__m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
// horizontal filter, polyphase implementation since it's convenient:
// even pixels = 3*cur + prev = cur*4 + (prev - cur)
// odd pixels = 3*cur + next = cur*4 + (next - cur)
// note the shared term.
__m128i bias = _mm_set1_epi16(8);
__m128i curs = _mm_slli_epi16(curr, 2);
__m128i prvd = _mm_sub_epi16(prev, curr);
__m128i nxtd = _mm_sub_epi16(next, curr);
__m128i curb = _mm_add_epi16(curs, bias);
__m128i even = _mm_add_epi16(prvd, curb);
__m128i odd = _mm_add_epi16(nxtd, curb);
// interleave even and odd pixels, then undo scaling.
__m128i int0 = _mm_unpacklo_epi16(even, odd);
__m128i int1 = _mm_unpackhi_epi16(even, odd);
__m128i de0 = _mm_srli_epi16(int0, 4);
__m128i de1 = _mm_srli_epi16(int1, 4);
// pack and write output
__m128i outv = _mm_packus_epi16(de0, de1);
_mm_storeu_si128((__m128i *) (out + i*2), outv);
#elif defined(STBI_NEON)
// load and perform the vertical filtering pass
// this uses 3*x + y = 4*x + (y - x)
uint8x8_t farb = vld1_u8(in_far + i);
uint8x8_t nearb = vld1_u8(in_near + i);
int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
int16x8_t curr = vaddq_s16(nears, diff); // current row
// horizontal filter works the same based on shifted vers of current
// row. "prev" is current row shifted right by 1 pixel; we need to
// insert the previous pixel value (from t1).
// "next" is current row shifted left by 1 pixel, with first pixel
// of next block of 8 pixels added in.
int16x8_t prv0 = vextq_s16(curr, curr, 7);
int16x8_t nxt0 = vextq_s16(curr, curr, 1);
int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
// horizontal filter, polyphase implementation since it's convenient:
// even pixels = 3*cur + prev = cur*4 + (prev - cur)
// odd pixels = 3*cur + next = cur*4 + (next - cur)
// note the shared term.
int16x8_t curs = vshlq_n_s16(curr, 2);
int16x8_t prvd = vsubq_s16(prev, curr);
int16x8_t nxtd = vsubq_s16(next, curr);
int16x8_t even = vaddq_s16(curs, prvd);
int16x8_t odd = vaddq_s16(curs, nxtd);
// undo scaling and round, then store with even/odd phases interleaved
uint8x8x2_t o;
o.val[0] = vqrshrun_n_s16(even, 4);
o.val[1] = vqrshrun_n_s16(odd, 4);
vst2_u8(out + i*2, o);
#endif
// "previous" value for next iter
t1 = 3*in_near[i+7] + in_far[i+7];
}
t0 = t1;
t1 = 3*in_near[i] + in_far[i];
out[i*2] = stbi__div16(3*t1 + t0 + 8);
for (++i; i < w; ++i) {
t0 = t1;
t1 = 3*in_near[i]+in_far[i];
out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
}
out[w*2-1] = stbi__div4(t1+2);
STBI_NOTUSED(hs);
return out;
}
#endif
static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// resample with nearest-neighbor
int i,j;
STBI_NOTUSED(in_far);
for (i=0; i < w; ++i)
for (j=0; j < hs; ++j)
out[i*hs+j] = in_near[i];
return out;
}
// this is a reduced-precision calculation of YCbCr-to-RGB introduced
// to make sure the code produces the same results in both SIMD and scalar
#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)
static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
{
int i;
for (i=0; i < count; ++i) {
int y_fixed = (y[i] << 20) + (1<<19); // rounding
int r,g,b;
int cr = pcr[i] - 128;
int cb = pcb[i] - 128;
r = y_fixed + cr* stbi__float2fixed(1.40200f);
g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
b = y_fixed + cb* stbi__float2fixed(1.77200f);
r >>= 20;
g >>= 20;
b >>= 20;
if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
out[0] = (stbi_uc)r;
out[1] = (stbi_uc)g;
out[2] = (stbi_uc)b;
out[3] = 255;
out += step;
}
}
#if defined(STBI_SSE2) || defined(STBI_NEON)
static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
{
int i = 0;
#ifdef STBI_SSE2
// step == 3 is pretty ugly on the final interleave, and i'm not convinced
// it's useful in practice (you wouldn't use it for textures, for example).
// so just accelerate step == 4 case.
if (step == 4) {
// this is a fairly straightforward implementation and not super-optimized.
__m128i signflip = _mm_set1_epi8(-0x80);
__m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f));
__m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
__m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
__m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f));
__m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
__m128i xw = _mm_set1_epi16(255); // alpha channel
for (; i+7 < count; i += 8) {
// load
__m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
__m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
__m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
__m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
__m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
// unpack to short (and left-shift cr, cb by 8)
__m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);
__m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
__m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
// color transform
__m128i yws = _mm_srli_epi16(yw, 4);
__m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
__m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
__m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
__m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
__m128i rws = _mm_add_epi16(cr0, yws);
__m128i gwt = _mm_add_epi16(cb0, yws);
__m128i bws = _mm_add_epi16(yws, cb1);
__m128i gws = _mm_add_epi16(gwt, cr1);
// descale
__m128i rw = _mm_srai_epi16(rws, 4);
__m128i bw = _mm_srai_epi16(bws, 4);
__m128i gw = _mm_srai_epi16(gws, 4);
// back to byte, set up for transpose
__m128i brb = _mm_packus_epi16(rw, bw);
__m128i gxb = _mm_packus_epi16(gw, xw);
// transpose to interleave channels
__m128i t0 = _mm_unpacklo_epi8(brb, gxb);
__m128i t1 = _mm_unpackhi_epi8(brb, gxb);
__m128i o0 = _mm_unpacklo_epi16(t0, t1);
__m128i o1 = _mm_unpackhi_epi16(t0, t1);
// store
_mm_storeu_si128((__m128i *) (out + 0), o0);
_mm_storeu_si128((__m128i *) (out + 16), o1);
out += 32;
}
}
#endif
#ifdef STBI_NEON
// in this version, step=3 support would be easy to add. but is there demand?
if (step == 4) {
// this is a fairly straightforward implementation and not super-optimized.
uint8x8_t signflip = vdup_n_u8(0x80);
int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f));
int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f));
for (; i+7 < count; i += 8) {
// load
uint8x8_t y_bytes = vld1_u8(y + i);
uint8x8_t cr_bytes = vld1_u8(pcr + i);
uint8x8_t cb_bytes = vld1_u8(pcb + i);
int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
// expand to s16
int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
int16x8_t crw = vshll_n_s8(cr_biased, 7);
int16x8_t cbw = vshll_n_s8(cb_biased, 7);
// color transform
int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
int16x8_t rws = vaddq_s16(yws, cr0);
int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
int16x8_t bws = vaddq_s16(yws, cb1);
// undo scaling, round, convert to byte
uint8x8x4_t o;
o.val[0] = vqrshrun_n_s16(rws, 4);
o.val[1] = vqrshrun_n_s16(gws, 4);
o.val[2] = vqrshrun_n_s16(bws, 4);
o.val[3] = vdup_n_u8(255);
// store, interleaving r/g/b/a
vst4_u8(out, o);
out += 8*4;
}
}
#endif
for (; i < count; ++i) {
int y_fixed = (y[i] << 20) + (1<<19); // rounding
int r,g,b;
int cr = pcr[i] - 128;
int cb = pcb[i] - 128;
r = y_fixed + cr* stbi__float2fixed(1.40200f);
g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
b = y_fixed + cb* stbi__float2fixed(1.77200f);
r >>= 20;
g >>= 20;
b >>= 20;
if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
out[0] = (stbi_uc)r;
out[1] = (stbi_uc)g;
out[2] = (stbi_uc)b;
out[3] = 255;
out += step;
}
}
#endif
// set up the kernels
static void stbi__setup_jpeg(stbi__jpeg *j)
{
j->idct_block_kernel = stbi__idct_block;
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
#ifdef STBI_SSE2
if (stbi__sse2_available()) {
j->idct_block_kernel = stbi__idct_simd;
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
}
#endif
#ifdef STBI_NEON
j->idct_block_kernel = stbi__idct_simd;
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
#endif
}
// clean up the temporary component buffers
static void stbi__cleanup_jpeg(stbi__jpeg *j)
{
stbi__free_jpeg_components(j, j->s->img_n, 0);
}
typedef struct
{
resample_row_func resample;
stbi_uc *line0,*line1;
int hs,vs; // expansion factor in each axis
int w_lores; // horizontal pixels pre-expansion
int ystep; // how far through vertical expansion we are
int ypos; // which pre-expansion row we're on
} stbi__resample;
// fast 0..255 * 0..255 => 0..255 rounded multiplication
static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
{
unsigned int t = x*y + 128;
return (stbi_uc) ((t + (t >>8)) >> 8);
}
static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
{
int n, decode_n, is_rgb;
z->s->img_n = 0; // make stbi__cleanup_jpeg safe
// validate req_comp
if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
// load a jpeg image from whichever source, but leave in YCbCr format
if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
// determine actual number of components to generate
n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
if (z->s->img_n == 3 && n < 3 && !is_rgb)
decode_n = 1;
else
decode_n = z->s->img_n;
// resample and color-convert
{
int k;
unsigned int i,j;
stbi_uc *output;
stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
stbi__resample res_comp[4];
for (k=0; k < decode_n; ++k) {
stbi__resample *r = &res_comp[k];
// allocate line buffer big enough for upsampling off the edges
// with upsample factor of 4
z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
r->hs = z->img_h_max / z->img_comp[k].h;
r->vs = z->img_v_max / z->img_comp[k].v;
r->ystep = r->vs >> 1;
r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
r->ypos = 0;
r->line0 = r->line1 = z->img_comp[k].data;
if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
else r->resample = stbi__resample_row_generic;
}
// can't error after this so, this is safe
output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
// now go ahead and resample
for (j=0; j < z->s->img_y; ++j) {
stbi_uc *out = output + n * z->s->img_x * j;
for (k=0; k < decode_n; ++k) {
stbi__resample *r = &res_comp[k];
int y_bot = r->ystep >= (r->vs >> 1);
coutput[k] = r->resample(z->img_comp[k].linebuf,
y_bot ? r->line1 : r->line0,
y_bot ? r->line0 : r->line1,
r->w_lores, r->hs);
if (++r->ystep >= r->vs) {
r->ystep = 0;
r->line0 = r->line1;
if (++r->ypos < z->img_comp[k].y)
r->line1 += z->img_comp[k].w2;
}
}
if (n >= 3) {
stbi_uc *y = coutput[0];
if (z->s->img_n == 3) {
if (is_rgb) {
for (i=0; i < z->s->img_x; ++i) {
out[0] = y[i];
out[1] = coutput[1][i];
out[2] = coutput[2][i];
out[3] = 255;
out += n;
}
} else {
z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
}
} else if (z->s->img_n == 4) {
if (z->app14_color_transform == 0) { // CMYK
for (i=0; i < z->s->img_x; ++i) {
stbi_uc m = coutput[3][i];
out[0] = stbi__blinn_8x8(coutput[0][i], m);
out[1] = stbi__blinn_8x8(coutput[1][i], m);
out[2] = stbi__blinn_8x8(coutput[2][i], m);
out[3] = 255;
out += n;
}
} else if (z->app14_color_transform == 2) { // YCCK
z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
for (i=0; i < z->s->img_x; ++i) {
stbi_uc m = coutput[3][i];
out[0] = stbi__blinn_8x8(255 - out[0], m);
out[1] = stbi__blinn_8x8(255 - out[1], m);
out[2] = stbi__blinn_8x8(255 - out[2], m);
out += n;
}
} else { // YCbCr + alpha? Ignore the fourth channel for now
z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
}
} else
for (i=0; i < z->s->img_x; ++i) {
out[0] = out[1] = out[2] = y[i];
out[3] = 255; // not used if n==3
out += n;
}
} else {
if (is_rgb) {
if (n == 1)
for (i=0; i < z->s->img_x; ++i)
*out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
else {
for (i=0; i < z->s->img_x; ++i, out += 2) {
out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
out[1] = 255;
}
}
} else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
for (i=0; i < z->s->img_x; ++i) {
stbi_uc m = coutput[3][i];
stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
out[0] = stbi__compute_y(r, g, b);
out[1] = 255;
out += n;
}
} else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
for (i=0; i < z->s->img_x; ++i) {
out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
out[1] = 255;
out += n;
}
} else {
stbi_uc *y = coutput[0];
if (n == 1)
for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
else
for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
}
}
}
stbi__cleanup_jpeg(z);
*out_x = z->s->img_x;
*out_y = z->s->img_y;
if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
return output;
}
}
static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
unsigned char* result;
stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
STBI_NOTUSED(ri);
j->s = s;
stbi__setup_jpeg(j);
result = load_jpeg_image(j, x,y,comp,req_comp);
STBI_FREE(j);
return result;
}
static int stbi__jpeg_test(stbi__context *s)
{
int r;
stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
j->s = s;
stbi__setup_jpeg(j);
r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
stbi__rewind(s);
STBI_FREE(j);
return r;
}
static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
{
if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
stbi__rewind( j->s );
return 0;
}
if (x) *x = j->s->img_x;
if (y) *y = j->s->img_y;
if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
return 1;
}
static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
{
int result;
stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
j->s = s;
result = stbi__jpeg_info_raw(j, x, y, comp);
STBI_FREE(j);
return result;
}
#endif
// public domain zlib decode v0.2 Sean Barrett 2006-11-18
// simple implementation
// - all input must be provided in an upfront buffer
// - all output is written to a single output buffer (can malloc/realloc)
// performance
// - fast huffman
#ifndef STBI_NO_ZLIB
// fast-way is faster to check than jpeg huffman, but slow way is slower
#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables
#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
// zlib-style huffman encoding
// (jpegs packs from left, zlib from right, so can't share code)
typedef struct
{
stbi__uint16 fast[1 << STBI__ZFAST_BITS];
stbi__uint16 firstcode[16];
int maxcode[17];
stbi__uint16 firstsymbol[16];
stbi_uc size[288];
stbi__uint16 value[288];
} stbi__zhuffman;
stbi_inline static int stbi__bitreverse16(int n)
{
n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
return n;
}
stbi_inline static int stbi__bit_reverse(int v, int bits)
{
STBI_ASSERT(bits <= 16);
// to bit reverse n bits, reverse 16 and shift
// e.g. 11 bits, bit reverse and shift away 5
return stbi__bitreverse16(v) >> (16-bits);
}
static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
{
int i,k=0;
int code, next_code[16], sizes[17];
// DEFLATE spec for generating codes
memset(sizes, 0, sizeof(sizes));
memset(z->fast, 0, sizeof(z->fast));
for (i=0; i < num; ++i)
++sizes[sizelist[i]];
sizes[0] = 0;
for (i=1; i < 16; ++i)
if (sizes[i] > (1 << i))
return stbi__err("bad sizes", "Corrupt PNG");
code = 0;
for (i=1; i < 16; ++i) {
next_code[i] = code;
z->firstcode[i] = (stbi__uint16) code;
z->firstsymbol[i] = (stbi__uint16) k;
code = (code + sizes[i]);
if (sizes[i])
if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
z->maxcode[i] = code << (16-i); // preshift for inner loop
code <<= 1;
k += sizes[i];
}
z->maxcode[16] = 0x10000; // sentinel
for (i=0; i < num; ++i) {
int s = sizelist[i];
if (s) {
int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
z->size [c] = (stbi_uc ) s;
z->value[c] = (stbi__uint16) i;
if (s <= STBI__ZFAST_BITS) {
int j = stbi__bit_reverse(next_code[s],s);
while (j < (1 << STBI__ZFAST_BITS)) {
z->fast[j] = fastv;
j += (1 << s);
}
}
++next_code[s];
}
}
return 1;
}
// zlib-from-memory implementation for PNG reading
// because PNG allows splitting the zlib stream arbitrarily,
// and it's annoying structurally to have PNG call ZLIB call PNG,
// we require PNG read all the IDATs and combine them into a single
// memory buffer
typedef struct
{
stbi_uc *zbuffer, *zbuffer_end;
int num_bits;
stbi__uint32 code_buffer;
char *zout;
char *zout_start;
char *zout_end;
int z_expandable;
stbi__zhuffman z_length, z_distance;
} stbi__zbuf;
stbi_inline static int stbi__zeof(stbi__zbuf *z)
{
return (z->zbuffer >= z->zbuffer_end);
}
stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
{
return stbi__zeof(z) ? 0 : *z->zbuffer++;
}
static void stbi__fill_bits(stbi__zbuf *z)
{
do {
if (z->code_buffer >= (1U << z->num_bits)) {
z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */
return;
}
z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
z->num_bits += 8;
} while (z->num_bits <= 24);
}
stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
{
unsigned int k;
if (z->num_bits < n) stbi__fill_bits(z);
k = z->code_buffer & ((1 << n) - 1);
z->code_buffer >>= n;
z->num_bits -= n;
return k;
}
static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
{
int b,s,k;
// not resolved by fast table, so compute it the slow way
// use jpeg approach, which requires MSbits at top
k = stbi__bit_reverse(a->code_buffer, 16);
for (s=STBI__ZFAST_BITS+1; ; ++s)
if (k < z->maxcode[s])
break;
if (s >= 16) return -1; // invalid code!
// code size is s, so:
b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
if (b >= sizeof (z->size)) return -1; // some data was corrupt somewhere!
if (z->size[b] != s) return -1; // was originally an assert, but report failure instead.
a->code_buffer >>= s;
a->num_bits -= s;
return z->value[b];
}
stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
{
int b,s;
if (a->num_bits < 16) {
if (stbi__zeof(a)) {
return -1; /* report error for unexpected end of data. */
}
stbi__fill_bits(a);
}
b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
if (b) {
s = b >> 9;
a->code_buffer >>= s;
a->num_bits -= s;
return b & 511;
}
return stbi__zhuffman_decode_slowpath(a, z);
}
static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
{
char *q;
unsigned int cur, limit, old_limit;
z->zout = zout;
if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
cur = (unsigned int) (z->zout - z->zout_start);
limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
while (cur + n > limit) {
if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
limit *= 2;
}
q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
STBI_NOTUSED(old_limit);
if (q == NULL) return stbi__err("outofmem", "Out of memory");
z->zout_start = q;
z->zout = q + cur;
z->zout_end = q + limit;
return 1;
}
static const int stbi__zlength_base[31] = {
3,4,5,6,7,8,9,10,11,13,
15,17,19,23,27,31,35,43,51,59,
67,83,99,115,131,163,195,227,258,0,0 };
static const int stbi__zlength_extra[31]=
{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
static const int stbi__zdist_extra[32] =
{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
static int stbi__parse_huffman_block(stbi__zbuf *a)
{
char *zout = a->zout;
for(;;) {
int z = stbi__zhuffman_decode(a, &a->z_length);
if (z < 256) {
if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
if (zout >= a->zout_end) {
if (!stbi__zexpand(a, zout, 1)) return 0;
zout = a->zout;
}
*zout++ = (char) z;
} else {
stbi_uc *p;
int len,dist;
if (z == 256) {
a->zout = zout;
return 1;
}
z -= 257;
len = stbi__zlength_base[z];
if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
z = stbi__zhuffman_decode(a, &a->z_distance);
if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");
dist = stbi__zdist_base[z];
if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
if (zout + len > a->zout_end) {
if (!stbi__zexpand(a, zout, len)) return 0;
zout = a->zout;
}
p = (stbi_uc *) (zout - dist);
if (dist == 1) { // run of one byte; common in images.
stbi_uc v = *p;
if (len) { do *zout++ = v; while (--len); }
} else {
if (len) { do *zout++ = *p++; while (--len); }
}
}
}
}
static int stbi__compute_huffman_codes(stbi__zbuf *a)
{
static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
stbi__zhuffman z_codelength;
stbi_uc lencodes[286+32+137];//padding for maximum single op
stbi_uc codelength_sizes[19];
int i,n;
int hlit = stbi__zreceive(a,5) + 257;
int hdist = stbi__zreceive(a,5) + 1;
int hclen = stbi__zreceive(a,4) + 4;
int ntot = hlit + hdist;
memset(codelength_sizes, 0, sizeof(codelength_sizes));
for (i=0; i < hclen; ++i) {
int s = stbi__zreceive(a,3);
codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
}
if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
n = 0;
while (n < ntot) {
int c = stbi__zhuffman_decode(a, &z_codelength);
if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
if (c < 16)
lencodes[n++] = (stbi_uc) c;
else {
stbi_uc fill = 0;
if (c == 16) {
c = stbi__zreceive(a,2)+3;
if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
fill = lencodes[n-1];
} else if (c == 17) {
c = stbi__zreceive(a,3)+3;
} else if (c == 18) {
c = stbi__zreceive(a,7)+11;
} else {
return stbi__err("bad codelengths", "Corrupt PNG");
}
if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
memset(lencodes+n, fill, c);
n += c;
}
}
if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
return 1;
}
static int stbi__parse_uncompressed_block(stbi__zbuf *a)
{
stbi_uc header[4];
int len,nlen,k;
if (a->num_bits & 7)
stbi__zreceive(a, a->num_bits & 7); // discard
// drain the bit-packed data into header
k = 0;
while (a->num_bits > 0) {
header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
a->code_buffer >>= 8;
a->num_bits -= 8;
}
if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
// now fill header the normal way
while (k < 4)
header[k++] = stbi__zget8(a);
len = header[1] * 256 + header[0];
nlen = header[3] * 256 + header[2];
if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
if (a->zout + len > a->zout_end)
if (!stbi__zexpand(a, a->zout, len)) return 0;
memcpy(a->zout, a->zbuffer, len);
a->zbuffer += len;
a->zout += len;
return 1;
}
static int stbi__parse_zlib_header(stbi__zbuf *a)
{
int cmf = stbi__zget8(a);
int cm = cmf & 15;
/* int cinfo = cmf >> 4; */
int flg = stbi__zget8(a);
if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
// window = 1 << (8 + cinfo)... but who cares, we fully buffer output
return 1;
}
static const stbi_uc stbi__zdefault_length[288] =
{
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8
};
static const stbi_uc stbi__zdefault_distance[32] =
{
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
};
/*
Init algorithm:
{
int i; // use <= to match clearly with spec
for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8;
for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9;
for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7;
for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8;
for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5;
}
*/
static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
{
int final, type;
if (parse_header)
if (!stbi__parse_zlib_header(a)) return 0;
a->num_bits = 0;
a->code_buffer = 0;
do {
final = stbi__zreceive(a,1);
type = stbi__zreceive(a,2);
if (type == 0) {
if (!stbi__parse_uncompressed_block(a)) return 0;
} else if (type == 3) {
return 0;
} else {
if (type == 1) {
// use fixed code lengths
if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288)) return 0;
if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0;
} else {
if (!stbi__compute_huffman_codes(a)) return 0;
}
if (!stbi__parse_huffman_block(a)) return 0;
}
} while (!final);
return 1;
}
static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
{
a->zout_start = obuf;
a->zout = obuf;
a->zout_end = obuf + olen;
a->z_expandable = exp;
return stbi__parse_zlib(a, parse_header);
}
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer + len;
if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
if (outlen) *outlen = (int) (a.zout - a.zout_start);
return a.zout_start;
} else {
STBI_FREE(a.zout_start);
return NULL;
}
}
STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
{
return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
}
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer + len;
if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
if (outlen) *outlen = (int) (a.zout - a.zout_start);
return a.zout_start;
} else {
STBI_FREE(a.zout_start);
return NULL;
}
}
STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
{
stbi__zbuf a;
a.zbuffer = (stbi_uc *) ibuffer;
a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
return (int) (a.zout - a.zout_start);
else
return -1;
}
STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(16384);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer+len;
if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
if (outlen) *outlen = (int) (a.zout - a.zout_start);
return a.zout_start;
} else {
STBI_FREE(a.zout_start);
return NULL;
}
}
STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
{
stbi__zbuf a;
a.zbuffer = (stbi_uc *) ibuffer;
a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
return (int) (a.zout - a.zout_start);
else
return -1;
}
#endif
// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18
// simple implementation
// - only 8-bit samples
// - no CRC checking
// - allocates lots of intermediate memory
// - avoids problem of streaming data between subsystems
// - avoids explicit window management
// performance
// - uses stb_zlib, a PD zlib implementation with fast huffman decoding
#ifndef STBI_NO_PNG
typedef struct
{
stbi__uint32 length;
stbi__uint32 type;
} stbi__pngchunk;
static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
{
stbi__pngchunk c;
c.length = stbi__get32be(s);
c.type = stbi__get32be(s);
return c;
}
static int stbi__check_png_header(stbi__context *s)
{
static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
int i;
for (i=0; i < 8; ++i)
if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
return 1;
}
typedef struct
{
stbi__context *s;
stbi_uc *idata, *expanded, *out;
int depth;
} stbi__png;
enum {
STBI__F_none=0,
STBI__F_sub=1,
STBI__F_up=2,
STBI__F_avg=3,
STBI__F_paeth=4,
// synthetic filters used for first scanline to avoid needing a dummy row of 0s
STBI__F_avg_first,
STBI__F_paeth_first
};
static stbi_uc first_row_filter[5] =
{
STBI__F_none,
STBI__F_sub,
STBI__F_none,
STBI__F_avg_first,
STBI__F_paeth_first
};
static int stbi__paeth(int a, int b, int c)
{
int p = a + b - c;
int pa = abs(p-a);
int pb = abs(p-b);
int pc = abs(p-c);
if (pa <= pb && pa <= pc) return a;
if (pb <= pc) return b;
return c;
}
static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
// create the png data from post-deflated data
static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
{
int bytes = (depth == 16? 2 : 1);
stbi__context *s = a->s;
stbi__uint32 i,j,stride = x*out_n*bytes;
stbi__uint32 img_len, img_width_bytes;
int k;
int img_n = s->img_n; // copy it into a local for later
int output_bytes = out_n*bytes;
int filter_bytes = img_n*bytes;
int width = x;
STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
if (!a->out) return stbi__err("outofmem", "Out of memory");
if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
img_width_bytes = (((img_n * x * depth) + 7) >> 3);
img_len = (img_width_bytes + 1) * y;
// we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
// but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
// so just check for raw_len < img_len always.
if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
for (j=0; j < y; ++j) {
stbi_uc *cur = a->out + stride*j;
stbi_uc *prior;
int filter = *raw++;
if (filter > 4)
return stbi__err("invalid filter","Corrupt PNG");
if (depth < 8) {
if (img_width_bytes > x) return stbi__err("invalid width","Corrupt PNG");
cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
filter_bytes = 1;
width = img_width_bytes;
}
prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above
// if first row, use special filter that doesn't sample previous row
if (j == 0) filter = first_row_filter[filter];
// handle first byte explicitly
for (k=0; k < filter_bytes; ++k) {
switch (filter) {
case STBI__F_none : cur[k] = raw[k]; break;
case STBI__F_sub : cur[k] = raw[k]; break;
case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
case STBI__F_avg_first : cur[k] = raw[k]; break;
case STBI__F_paeth_first: cur[k] = raw[k]; break;
}
}
if (depth == 8) {
if (img_n != out_n)
cur[img_n] = 255; // first pixel
raw += img_n;
cur += out_n;
prior += out_n;
} else if (depth == 16) {
if (img_n != out_n) {
cur[filter_bytes] = 255; // first pixel top byte
cur[filter_bytes+1] = 255; // first pixel bottom byte
}
raw += filter_bytes;
cur += output_bytes;
prior += output_bytes;
} else {
raw += 1;
cur += 1;
prior += 1;
}
// this is a little gross, so that we don't switch per-pixel or per-component
if (depth < 8 || img_n == out_n) {
int nk = (width - 1)*filter_bytes;
#define STBI__CASE(f) \
case f: \
for (k=0; k < nk; ++k)
switch (filter) {
// "none" filter turns into a memcpy here; make that explicit.
case STBI__F_none: memcpy(cur, raw, nk); break;
STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;
}
#undef STBI__CASE
raw += nk;
} else {
STBI_ASSERT(img_n+1 == out_n);
#define STBI__CASE(f) \
case f: \
for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
for (k=0; k < filter_bytes; ++k)
switch (filter) {
STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break;
STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;
}
#undef STBI__CASE
// the loop above sets the high byte of the pixels' alpha, but for
// 16 bit png files we also need the low byte set. we'll do that here.
if (depth == 16) {
cur = a->out + stride*j; // start at the beginning of the row again
for (i=0; i < x; ++i,cur+=output_bytes) {
cur[filter_bytes+1] = 255;
}
}
}
}
// we make a separate pass to expand bits to pixels; for performance,
// this could run two scanlines behind the above code, so it won't
// intefere with filtering but will still be in the cache.
if (depth < 8) {
for (j=0; j < y; ++j) {
stbi_uc *cur = a->out + stride*j;
stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes;
// unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
// png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
// note that the final byte might overshoot and write more data than desired.
// we can allocate enough data that this never writes out of memory, but it
// could also overwrite the next scanline. can it overwrite non-empty data
// on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
// so we need to explicitly clamp the final ones
if (depth == 4) {
for (k=x*img_n; k >= 2; k-=2, ++in) {
*cur++ = scale * ((*in >> 4) );
*cur++ = scale * ((*in ) & 0x0f);
}
if (k > 0) *cur++ = scale * ((*in >> 4) );
} else if (depth == 2) {
for (k=x*img_n; k >= 4; k-=4, ++in) {
*cur++ = scale * ((*in >> 6) );
*cur++ = scale * ((*in >> 4) & 0x03);
*cur++ = scale * ((*in >> 2) & 0x03);
*cur++ = scale * ((*in ) & 0x03);
}
if (k > 0) *cur++ = scale * ((*in >> 6) );
if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
} else if (depth == 1) {
for (k=x*img_n; k >= 8; k-=8, ++in) {
*cur++ = scale * ((*in >> 7) );
*cur++ = scale * ((*in >> 6) & 0x01);
*cur++ = scale * ((*in >> 5) & 0x01);
*cur++ = scale * ((*in >> 4) & 0x01);
*cur++ = scale * ((*in >> 3) & 0x01);
*cur++ = scale * ((*in >> 2) & 0x01);
*cur++ = scale * ((*in >> 1) & 0x01);
*cur++ = scale * ((*in ) & 0x01);
}
if (k > 0) *cur++ = scale * ((*in >> 7) );
if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
}
if (img_n != out_n) {
int q;
// insert alpha = 255
cur = a->out + stride*j;
if (img_n == 1) {
for (q=x-1; q >= 0; --q) {
cur[q*2+1] = 255;
cur[q*2+0] = cur[q];
}
} else {
STBI_ASSERT(img_n == 3);
for (q=x-1; q >= 0; --q) {
cur[q*4+3] = 255;
cur[q*4+2] = cur[q*3+2];
cur[q*4+1] = cur[q*3+1];
cur[q*4+0] = cur[q*3+0];
}
}
}
}
} else if (depth == 16) {
// force the image data from big-endian to platform-native.
// this is done in a separate pass due to the decoding relying
// on the data being untouched, but could probably be done
// per-line during decode if care is taken.
stbi_uc *cur = a->out;
stbi__uint16 *cur16 = (stbi__uint16*)cur;
for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
*cur16 = (cur[0] << 8) | cur[1];
}
}
return 1;
}
static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
{
int bytes = (depth == 16 ? 2 : 1);
int out_bytes = out_n * bytes;
stbi_uc *final;
int p;
if (!interlaced)
return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
// de-interlacing
final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
for (p=0; p < 7; ++p) {
int xorig[] = { 0,4,0,2,0,1,0 };
int yorig[] = { 0,0,4,0,2,0,1 };
int xspc[] = { 8,8,4,4,2,2,1 };
int yspc[] = { 8,8,8,4,4,2,2 };
int i,j,x,y;
// pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
if (x && y) {
stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
STBI_FREE(final);
return 0;
}
for (j=0; j < y; ++j) {
for (i=0; i < x; ++i) {
int out_y = j*yspc[p]+yorig[p];
int out_x = i*xspc[p]+xorig[p];
memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
a->out + (j*x+i)*out_bytes, out_bytes);
}
}
STBI_FREE(a->out);
image_data += img_len;
image_data_len -= img_len;
}
}
a->out = final;
return 1;
}
static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi_uc *p = z->out;
// compute color-based transparency, assuming we've
// already got 255 as the alpha value in the output
STBI_ASSERT(out_n == 2 || out_n == 4);
if (out_n == 2) {
for (i=0; i < pixel_count; ++i) {
p[1] = (p[0] == tc[0] ? 0 : 255);
p += 2;
}
} else {
for (i=0; i < pixel_count; ++i) {
if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
p[3] = 0;
p += 4;
}
}
return 1;
}
static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi__uint16 *p = (stbi__uint16*) z->out;
// compute color-based transparency, assuming we've
// already got 65535 as the alpha value in the output
STBI_ASSERT(out_n == 2 || out_n == 4);
if (out_n == 2) {
for (i = 0; i < pixel_count; ++i) {
p[1] = (p[0] == tc[0] ? 0 : 65535);
p += 2;
}
} else {
for (i = 0; i < pixel_count; ++i) {
if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
p[3] = 0;
p += 4;
}
}
return 1;
}
static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
{
stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
stbi_uc *p, *temp_out, *orig = a->out;
p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
if (p == NULL) return stbi__err("outofmem", "Out of memory");
// between here and free(out) below, exitting would leak
temp_out = p;
if (pal_img_n == 3) {
for (i=0; i < pixel_count; ++i) {
int n = orig[i]*4;
p[0] = palette[n ];
p[1] = palette[n+1];
p[2] = palette[n+2];
p += 3;
}
} else {
for (i=0; i < pixel_count; ++i) {
int n = orig[i]*4;
p[0] = palette[n ];
p[1] = palette[n+1];
p[2] = palette[n+2];
p[3] = palette[n+3];
p += 4;
}
}
STBI_FREE(a->out);
a->out = temp_out;
STBI_NOTUSED(len);
return 1;
}
static int stbi__unpremultiply_on_load = 0;
static int stbi__de_iphone_flag = 0;
STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
{
stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply;
}
STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
{
stbi__de_iphone_flag = flag_true_if_should_convert;
}
static void stbi__de_iphone(stbi__png *z)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi_uc *p = z->out;
if (s->img_out_n == 3) { // convert bgr to rgb
for (i=0; i < pixel_count; ++i) {
stbi_uc t = p[0];
p[0] = p[2];
p[2] = t;
p += 3;
}
} else {
STBI_ASSERT(s->img_out_n == 4);
if (stbi__unpremultiply_on_load) {
// convert bgr to rgb and unpremultiply
for (i=0; i < pixel_count; ++i) {
stbi_uc a = p[3];
stbi_uc t = p[0];
if (a) {
stbi_uc half = a / 2;
p[0] = (p[2] * 255 + half) / a;
p[1] = (p[1] * 255 + half) / a;
p[2] = ( t * 255 + half) / a;
} else {
p[0] = p[2];
p[2] = t;
}
p += 4;
}
} else {
// convert bgr to rgb
for (i=0; i < pixel_count; ++i) {
stbi_uc t = p[0];
p[0] = p[2];
p[2] = t;
p += 4;
}
}
}
}
#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
{
stbi_uc palette[1024], pal_img_n=0;
stbi_uc has_trans=0, tc[3]={0};
stbi__uint16 tc16[3];
stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
int first=1,k,interlace=0, color=0, is_iphone=0;
stbi__context *s = z->s;
z->expanded = NULL;
z->idata = NULL;
z->out = NULL;
if (!stbi__check_png_header(s)) return 0;
if (scan == STBI__SCAN_type) return 1;
for (;;) {
stbi__pngchunk c = stbi__get_chunk_header(s);
switch (c.type) {
case STBI__PNG_TYPE('C','g','B','I'):
is_iphone = 1;
stbi__skip(s, c.length);
break;
case STBI__PNG_TYPE('I','H','D','R'): {
int comp,filter;
if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
first = 0;
if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
s->img_x = stbi__get32be(s);
s->img_y = stbi__get32be(s);
if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG");
if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG");
if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG");
filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG");
interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
if (!pal_img_n) {
s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
if (scan == STBI__SCAN_header) return 1;
} else {
// if paletted, then pal_n is our final components, and
// img_n is # components to decompress/filter.
s->img_n = 1;
if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
// if SCAN_header, have to scan to see if we have a tRNS
}
break;
}
case STBI__PNG_TYPE('P','L','T','E'): {
if (first) return stbi__err("first not IHDR", "Corrupt PNG");
if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
pal_len = c.length / 3;
if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
for (i=0; i < pal_len; ++i) {
palette[i*4+0] = stbi__get8(s);
palette[i*4+1] = stbi__get8(s);
palette[i*4+2] = stbi__get8(s);
palette[i*4+3] = 255;
}
break;
}
case STBI__PNG_TYPE('t','R','N','S'): {
if (first) return stbi__err("first not IHDR", "Corrupt PNG");
if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
if (pal_img_n) {
if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
pal_img_n = 4;
for (i=0; i < c.length; ++i)
palette[i*4+3] = stbi__get8(s);
} else {
if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
has_trans = 1;
if (z->depth == 16) {
for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
} else {
for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
}
}
break;
}
case STBI__PNG_TYPE('I','D','A','T'): {
if (first) return stbi__err("first not IHDR", "Corrupt PNG");
if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }
if ((int)(ioff + c.length) < (int)ioff) return 0;
if (ioff + c.length > idata_limit) {
stbi__uint32 idata_limit_old = idata_limit;
stbi_uc *p;
if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
while (ioff + c.length > idata_limit)
idata_limit *= 2;
STBI_NOTUSED(idata_limit_old);
p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
z->idata = p;
}
if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
ioff += c.length;
break;
}
case STBI__PNG_TYPE('I','E','N','D'): {
stbi__uint32 raw_len, bpl;
if (first) return stbi__err("first not IHDR", "Corrupt PNG");
if (scan != STBI__SCAN_load) return 1;
if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
// initial guess for decoded data size to avoid unnecessary reallocs
bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
if (z->expanded == NULL) return 0; // zlib should set error
STBI_FREE(z->idata); z->idata = NULL;
if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
s->img_out_n = s->img_n+1;
else
s->img_out_n = s->img_n;
if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
if (has_trans) {
if (z->depth == 16) {
if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
} else {
if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
}
}
if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
stbi__de_iphone(z);
if (pal_img_n) {
// pal_img_n == 3 or 4
s->img_n = pal_img_n; // record the actual colors we had
s->img_out_n = pal_img_n;
if (req_comp >= 3) s->img_out_n = req_comp;
if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
return 0;
} else if (has_trans) {
// non-paletted image with tRNS -> source image has (constant) alpha
++s->img_n;
}
STBI_FREE(z->expanded); z->expanded = NULL;
// end of PNG chunk, read and skip CRC
stbi__get32be(s);
return 1;
}
default:
// if critical, fail
if (first) return stbi__err("first not IHDR", "Corrupt PNG");
if ((c.type & (1 << 29)) == 0) {
#ifndef STBI_NO_FAILURE_STRINGS
// not threadsafe
static char invalid_chunk[] = "XXXX PNG chunk not known";
invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);
invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);
#endif
return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
}
stbi__skip(s, c.length);
break;
}
// end of PNG chunk, read and skip CRC
stbi__get32be(s);
}
}
static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
{
void *result=NULL;
if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
if (p->depth <= 8)
ri->bits_per_channel = 8;
else if (p->depth == 16)
ri->bits_per_channel = 16;
else
return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");
result = p->out;
p->out = NULL;
if (req_comp && req_comp != p->s->img_out_n) {
if (ri->bits_per_channel == 8)
result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
else
result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
p->s->img_out_n = req_comp;
if (result == NULL) return result;
}
*x = p->s->img_x;
*y = p->s->img_y;
if (n) *n = p->s->img_n;
}
STBI_FREE(p->out); p->out = NULL;
STBI_FREE(p->expanded); p->expanded = NULL;
STBI_FREE(p->idata); p->idata = NULL;
return result;
}
static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
stbi__png p;
p.s = s;
return stbi__do_png(&p, x,y,comp,req_comp, ri);
}
static int stbi__png_test(stbi__context *s)
{
int r;
r = stbi__check_png_header(s);
stbi__rewind(s);
return r;
}
static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
{
if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
stbi__rewind( p->s );
return 0;
}
if (x) *x = p->s->img_x;
if (y) *y = p->s->img_y;
if (comp) *comp = p->s->img_n;
return 1;
}
static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
{
stbi__png p;
p.s = s;
return stbi__png_info_raw(&p, x, y, comp);
}
static int stbi__png_is16(stbi__context *s)
{
stbi__png p;
p.s = s;
if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
return 0;
if (p.depth != 16) {
stbi__rewind(p.s);
return 0;
}
return 1;
}
#endif
// Microsoft/Windows BMP image
#ifndef STBI_NO_BMP
static int stbi__bmp_test_raw(stbi__context *s)
{
int r;
int sz;
if (stbi__get8(s) != 'B') return 0;
if (stbi__get8(s) != 'M') return 0;
stbi__get32le(s); // discard filesize
stbi__get16le(s); // discard reserved
stbi__get16le(s); // discard reserved
stbi__get32le(s); // discard data offset
sz = stbi__get32le(s);
r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
return r;
}
static int stbi__bmp_test(stbi__context *s)
{
int r = stbi__bmp_test_raw(s);
stbi__rewind(s);
return r;
}
// returns 0..31 for the highest set bit
static int stbi__high_bit(unsigned int z)
{
int n=0;
if (z == 0) return -1;
if (z >= 0x10000) { n += 16; z >>= 16; }
if (z >= 0x00100) { n += 8; z >>= 8; }
if (z >= 0x00010) { n += 4; z >>= 4; }
if (z >= 0x00004) { n += 2; z >>= 2; }
if (z >= 0x00002) { n += 1;/* >>= 1;*/ }
return n;
}
static int stbi__bitcount(unsigned int a)
{
a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
a = (a + (a >> 8)); // max 16 per 8 bits
a = (a + (a >> 16)); // max 32 per 8 bits
return a & 0xff;
}
// extract an arbitrarily-aligned N-bit value (N=bits)
// from v, and then make it 8-bits long and fractionally
// extend it to full full range.
static int stbi__shiftsigned(unsigned int v, int shift, int bits)
{
static unsigned int mul_table[9] = {
0,
0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
};
static unsigned int shift_table[9] = {
0, 0,0,1,0,2,4,6,0,
};
if (shift < 0)
v <<= -shift;
else
v >>= shift;
STBI_ASSERT(v < 256);
v >>= (8-bits);
STBI_ASSERT(bits >= 0 && bits <= 8);
return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
}
typedef struct
{
int bpp, offset, hsz;
unsigned int mr,mg,mb,ma, all_a;
int extra_read;
} stbi__bmp_data;
static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
{
int hsz;
if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
stbi__get32le(s); // discard filesize
stbi__get16le(s); // discard reserved
stbi__get16le(s); // discard reserved
info->offset = stbi__get32le(s);
info->hsz = hsz = stbi__get32le(s);
info->mr = info->mg = info->mb = info->ma = 0;
info->extra_read = 14;
if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");
if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
if (hsz == 12) {
s->img_x = stbi__get16le(s);
s->img_y = stbi__get16le(s);
} else {
s->img_x = stbi__get32le(s);
s->img_y = stbi__get32le(s);
}
if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
info->bpp = stbi__get16le(s);
if (hsz != 12) {
int compress = stbi__get32le(s);
if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
stbi__get32le(s); // discard sizeof
stbi__get32le(s); // discard hres
stbi__get32le(s); // discard vres
stbi__get32le(s); // discard colorsused
stbi__get32le(s); // discard max important
if (hsz == 40 || hsz == 56) {
if (hsz == 56) {
stbi__get32le(s);
stbi__get32le(s);
stbi__get32le(s);
stbi__get32le(s);
}
if (info->bpp == 16 || info->bpp == 32) {
if (compress == 0) {
if (info->bpp == 32) {
info->mr = 0xffu << 16;
info->mg = 0xffu << 8;
info->mb = 0xffu << 0;
info->ma = 0xffu << 24;
info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
} else {
info->mr = 31u << 10;
info->mg = 31u << 5;
info->mb = 31u << 0;
}
} else if (compress == 3) {
info->mr = stbi__get32le(s);
info->mg = stbi__get32le(s);
info->mb = stbi__get32le(s);
info->extra_read += 12;
// not documented, but generated by photoshop and handled by mspaint
if (info->mr == info->mg && info->mg == info->mb) {
// ?!?!?
return stbi__errpuc("bad BMP", "bad BMP");
}
} else
return stbi__errpuc("bad BMP", "bad BMP");
}
} else {
int i;
if (hsz != 108 && hsz != 124)
return stbi__errpuc("bad BMP", "bad BMP");
info->mr = stbi__get32le(s);
info->mg = stbi__get32le(s);
info->mb = stbi__get32le(s);
info->ma = stbi__get32le(s);
stbi__get32le(s); // discard color space
for (i=0; i < 12; ++i)
stbi__get32le(s); // discard color space parameters
if (hsz == 124) {
stbi__get32le(s); // discard rendering intent
stbi__get32le(s); // discard offset of profile data
stbi__get32le(s); // discard size of profile data
stbi__get32le(s); // discard reserved
}
}
}
return (void *) 1;
}
static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
stbi_uc *out;
unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
stbi_uc pal[256][4];
int psize=0,i,j,width;
int flip_vertically, pad, target;
stbi__bmp_data info;
STBI_NOTUSED(ri);
info.all_a = 255;
if (stbi__bmp_parse_header(s, &info) == NULL)
return NULL; // error code already set
flip_vertically = ((int) s->img_y) > 0;
s->img_y = abs((int) s->img_y);
if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
mr = info.mr;
mg = info.mg;
mb = info.mb;
ma = info.ma;
all_a = info.all_a;
if (info.hsz == 12) {
if (info.bpp < 24)
psize = (info.offset - info.extra_read - 24) / 3;
} else {
if (info.bpp < 16)
psize = (info.offset - info.extra_read - info.hsz) >> 2;
}
if (psize == 0) {
STBI_ASSERT(info.offset == s->callback_already_read + (int) (s->img_buffer - s->img_buffer_original));
if (info.offset != s->callback_already_read + (s->img_buffer - s->buffer_start)) {
return stbi__errpuc("bad offset", "Corrupt BMP");
}
}
if (info.bpp == 24 && ma == 0xff000000)
s->img_n = 3;
else
s->img_n = ma ? 4 : 3;
if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
target = req_comp;
else
target = s->img_n; // if they want monochrome, we'll post-convert
// sanity-check size
if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
return stbi__errpuc("too large", "Corrupt BMP");
out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
if (!out) return stbi__errpuc("outofmem", "Out of memory");
if (info.bpp < 16) {
int z=0;
if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
for (i=0; i < psize; ++i) {
pal[i][2] = stbi__get8(s);
pal[i][1] = stbi__get8(s);
pal[i][0] = stbi__get8(s);
if (info.hsz != 12) stbi__get8(s);
pal[i][3] = 255;
}
stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
if (info.bpp == 1) width = (s->img_x + 7) >> 3;
else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
else if (info.bpp == 8) width = s->img_x;
else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
pad = (-width)&3;
if (info.bpp == 1) {
for (j=0; j < (int) s->img_y; ++j) {
int bit_offset = 7, v = stbi__get8(s);
for (i=0; i < (int) s->img_x; ++i) {
int color = (v>>bit_offset)&0x1;
out[z++] = pal[color][0];
out[z++] = pal[color][1];
out[z++] = pal[color][2];
if (target == 4) out[z++] = 255;
if (i+1 == (int) s->img_x) break;
if((--bit_offset) < 0) {
bit_offset = 7;
v = stbi__get8(s);
}
}
stbi__skip(s, pad);
}
} else {
for (j=0; j < (int) s->img_y; ++j) {
for (i=0; i < (int) s->img_x; i += 2) {
int v=stbi__get8(s),v2=0;
if (info.bpp == 4) {
v2 = v & 15;
v >>= 4;
}
out[z++] = pal[v][0];
out[z++] = pal[v][1];
out[z++] = pal[v][2];
if (target == 4) out[z++] = 255;
if (i+1 == (int) s->img_x) break;
v = (info.bpp == 8) ? stbi__get8(s) : v2;
out[z++] = pal[v][0];
out[z++] = pal[v][1];
out[z++] = pal[v][2];
if (target == 4) out[z++] = 255;
}
stbi__skip(s, pad);
}
}
} else {
int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
int z = 0;
int easy=0;
stbi__skip(s, info.offset - info.extra_read - info.hsz);
if (info.bpp == 24) width = 3 * s->img_x;
else if (info.bpp == 16) width = 2*s->img_x;
else /* bpp = 32 and pad = 0 */ width=0;
pad = (-width) & 3;
if (info.bpp == 24) {
easy = 1;
} else if (info.bpp == 32) {
if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
easy = 2;
}
if (!easy) {
if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
// right shift amt to put high bit in position #7
rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
}
for (j=0; j < (int) s->img_y; ++j) {
if (easy) {
for (i=0; i < (int) s->img_x; ++i) {
unsigned char a;
out[z+2] = stbi__get8(s);
out[z+1] = stbi__get8(s);
out[z+0] = stbi__get8(s);
z += 3;
a = (easy == 2 ? stbi__get8(s) : 255);
all_a |= a;
if (target == 4) out[z++] = a;
}
} else {
int bpp = info.bpp;
for (i=0; i < (int) s->img_x; ++i) {
stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
unsigned int a;
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
all_a |= a;
if (target == 4) out[z++] = STBI__BYTECAST(a);
}
}
stbi__skip(s, pad);
}
}
// if alpha channel is all 0s, replace with all 255s
if (target == 4 && all_a == 0)
for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
out[i] = 255;
if (flip_vertically) {
stbi_uc t;
for (j=0; j < (int) s->img_y>>1; ++j) {
stbi_uc *p1 = out + j *s->img_x*target;
stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
for (i=0; i < (int) s->img_x*target; ++i) {
t = p1[i]; p1[i] = p2[i]; p2[i] = t;
}
}
}
if (req_comp && req_comp != target) {
out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
if (out == NULL) return out; // stbi__convert_format frees input on failure
}
*x = s->img_x;
*y = s->img_y;
if (comp) *comp = s->img_n;
return out;
}
#endif
// Targa Truevision - TGA
// by Jonathan Dummer
#ifndef STBI_NO_TGA
// returns STBI_rgb or whatever, 0 on error
static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
{
// only RGB or RGBA (incl. 16bit) or grey allowed
if (is_rgb16) *is_rgb16 = 0;
switch(bits_per_pixel) {
case 8: return STBI_grey;
case 16: if(is_grey) return STBI_grey_alpha;
// fallthrough
case 15: if(is_rgb16) *is_rgb16 = 1;
return STBI_rgb;
case 24: // fallthrough
case 32: return bits_per_pixel/8;
default: return 0;
}
}
static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
{
int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
int sz, tga_colormap_type;
stbi__get8(s); // discard Offset
tga_colormap_type = stbi__get8(s); // colormap type
if( tga_colormap_type > 1 ) {
stbi__rewind(s);
return 0; // only RGB or indexed allowed
}
tga_image_type = stbi__get8(s); // image type
if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
if (tga_image_type != 1 && tga_image_type != 9) {
stbi__rewind(s);
return 0;
}
stbi__skip(s,4); // skip index of first colormap entry and number of entries
sz = stbi__get8(s); // check bits per palette color entry
if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
stbi__rewind(s);
return 0;
}
stbi__skip(s,4); // skip image x and y origin
tga_colormap_bpp = sz;
} else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
stbi__rewind(s);
return 0; // only RGB or grey allowed, +/- RLE
}
stbi__skip(s,9); // skip colormap specification and image x/y origin
tga_colormap_bpp = 0;
}
tga_w = stbi__get16le(s);
if( tga_w < 1 ) {
stbi__rewind(s);
return 0; // test width
}
tga_h = stbi__get16le(s);
if( tga_h < 1 ) {
stbi__rewind(s);
return 0; // test height
}
tga_bits_per_pixel = stbi__get8(s); // bits per pixel
stbi__get8(s); // ignore alpha bits
if (tga_colormap_bpp != 0) {
if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
// when using a colormap, tga_bits_per_pixel is the size of the indexes
// I don't think anything but 8 or 16bit indexes makes sense
stbi__rewind(s);
return 0;
}
tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
} else {
tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
}
if(!tga_comp) {
stbi__rewind(s);
return 0;
}
if (x) *x = tga_w;
if (y) *y = tga_h;
if (comp) *comp = tga_comp;
return 1; // seems to have passed everything
}
static int stbi__tga_test(stbi__context *s)
{
int res = 0;
int sz, tga_color_type;
stbi__get8(s); // discard Offset
tga_color_type = stbi__get8(s); // color type
if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed
sz = stbi__get8(s); // image type
if ( tga_color_type == 1 ) { // colormapped (paletted) image
if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
stbi__skip(s,4); // skip index of first colormap entry and number of entries
sz = stbi__get8(s); // check bits per palette color entry
if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
stbi__skip(s,4); // skip image x and y origin
} else { // "normal" image w/o colormap
if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
stbi__skip(s,9); // skip colormap specification and image x/y origin
}
if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width
if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height
sz = stbi__get8(s); // bits per pixel
if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
res = 1; // if we got this far, everything's good and we can return 1 instead of 0
errorEnd:
stbi__rewind(s);
return res;
}
// read 16bit value and convert to 24bit RGB
static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
{
stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
stbi__uint16 fiveBitMask = 31;
// we have 3 channels with 5bits each
int r = (px >> 10) & fiveBitMask;
int g = (px >> 5) & fiveBitMask;
int b = px & fiveBitMask;
// Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
out[0] = (stbi_uc)((r * 255)/31);
out[1] = (stbi_uc)((g * 255)/31);
out[2] = (stbi_uc)((b * 255)/31);
// some people claim that the most significant bit might be used for alpha
// (possibly if an alpha-bit is set in the "image descriptor byte")
// but that only made 16bit test images completely translucent..
// so let's treat all 15 and 16bit TGAs as RGB with no alpha.
}
static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
// read in the TGA header stuff
int tga_offset = stbi__get8(s);
int tga_indexed = stbi__get8(s);
int tga_image_type = stbi__get8(s);
int tga_is_RLE = 0;
int tga_palette_start = stbi__get16le(s);
int tga_palette_len = stbi__get16le(s);
int tga_palette_bits = stbi__get8(s);
int tga_x_origin = stbi__get16le(s);
int tga_y_origin = stbi__get16le(s);
int tga_width = stbi__get16le(s);
int tga_height = stbi__get16le(s);
int tga_bits_per_pixel = stbi__get8(s);
int tga_comp, tga_rgb16=0;
int tga_inverted = stbi__get8(s);
// int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
// image data
unsigned char *tga_data;
unsigned char *tga_palette = NULL;
int i, j;
unsigned char raw_data[4] = {0};
int RLE_count = 0;
int RLE_repeating = 0;
int read_next_pixel = 1;
STBI_NOTUSED(ri);
STBI_NOTUSED(tga_x_origin); // @TODO
STBI_NOTUSED(tga_y_origin); // @TODO
if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
// do a tiny bit of precessing
if ( tga_image_type >= 8 )
{
tga_image_type -= 8;
tga_is_RLE = 1;
}
tga_inverted = 1 - ((tga_inverted >> 5) & 1);
// If I'm paletted, then I'll use the number of bits from the palette
if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
// tga info
*x = tga_width;
*y = tga_height;
if (comp) *comp = tga_comp;
if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
return stbi__errpuc("too large", "Corrupt TGA");
tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
// skip to the data's starting position (offset usually = 0)
stbi__skip(s, tga_offset );
if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
for (i=0; i < tga_height; ++i) {
int row = tga_inverted ? tga_height -i - 1 : i;
stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
stbi__getn(s, tga_row, tga_width * tga_comp);
}
} else {
// do I need to load a palette?
if ( tga_indexed)
{
if (tga_palette_len == 0) { /* you have to have at least one entry! */
STBI_FREE(tga_data);
return stbi__errpuc("bad palette", "Corrupt TGA");
}
// any data to skip? (offset usually = 0)
stbi__skip(s, tga_palette_start );
// load the palette
tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
if (!tga_palette) {
STBI_FREE(tga_data);
return stbi__errpuc("outofmem", "Out of memory");
}
if (tga_rgb16) {
stbi_uc *pal_entry = tga_palette;
STBI_ASSERT(tga_comp == STBI_rgb);
for (i=0; i < tga_palette_len; ++i) {
stbi__tga_read_rgb16(s, pal_entry);
pal_entry += tga_comp;
}
} else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
STBI_FREE(tga_data);
STBI_FREE(tga_palette);
return stbi__errpuc("bad palette", "Corrupt TGA");
}
}
// load the data
for (i=0; i < tga_width * tga_height; ++i)
{
// if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
if ( tga_is_RLE )
{
if ( RLE_count == 0 )
{
// yep, get the next byte as a RLE command
int RLE_cmd = stbi__get8(s);
RLE_count = 1 + (RLE_cmd & 127);
RLE_repeating = RLE_cmd >> 7;
read_next_pixel = 1;
} else if ( !RLE_repeating )
{
read_next_pixel = 1;
}
} else
{
read_next_pixel = 1;
}
// OK, if I need to read a pixel, do it now
if ( read_next_pixel )
{
// load however much data we did have
if ( tga_indexed )
{
// read in index, then perform the lookup
int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
if ( pal_idx >= tga_palette_len ) {
// invalid index
pal_idx = 0;
}
pal_idx *= tga_comp;
for (j = 0; j < tga_comp; ++j) {
raw_data[j] = tga_palette[pal_idx+j];
}
} else if(tga_rgb16) {
STBI_ASSERT(tga_comp == STBI_rgb);
stbi__tga_read_rgb16(s, raw_data);
} else {
// read in the data raw
for (j = 0; j < tga_comp; ++j) {
raw_data[j] = stbi__get8(s);
}
}
// clear the reading flag for the next pixel
read_next_pixel = 0;
} // end of reading a pixel
// copy data
for (j = 0; j < tga_comp; ++j)
tga_data[i*tga_comp+j] = raw_data[j];
// in case we're in RLE mode, keep counting down
--RLE_count;
}
// do I need to invert the image?
if ( tga_inverted )
{
for (j = 0; j*2 < tga_height; ++j)
{
int index1 = j * tga_width * tga_comp;
int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
for (i = tga_width * tga_comp; i > 0; --i)
{
unsigned char temp = tga_data[index1];
tga_data[index1] = tga_data[index2];
tga_data[index2] = temp;
++index1;
++index2;
}
}
}
// clear my palette, if I had one
if ( tga_palette != NULL )
{
STBI_FREE( tga_palette );
}
}
// swap RGB - if the source data was RGB16, it already is in the right order
if (tga_comp >= 3 && !tga_rgb16)
{
unsigned char* tga_pixel = tga_data;
for (i=0; i < tga_width * tga_height; ++i)
{
unsigned char temp = tga_pixel[0];
tga_pixel[0] = tga_pixel[2];
tga_pixel[2] = temp;
tga_pixel += tga_comp;
}
}
// convert to target component count
if (req_comp && req_comp != tga_comp)
tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
// the things I do to get rid of an error message, and yet keep
// Microsoft's C compilers happy... [8^(
tga_palette_start = tga_palette_len = tga_palette_bits =
tga_x_origin = tga_y_origin = 0;
STBI_NOTUSED(tga_palette_start);
// OK, done
return tga_data;
}
#endif
// *************************************************************************************************
// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
#ifndef STBI_NO_PSD
static int stbi__psd_test(stbi__context *s)
{
int r = (stbi__get32be(s) == 0x38425053);
stbi__rewind(s);
return r;
}
static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
{
int count, nleft, len;
count = 0;
while ((nleft = pixelCount - count) > 0) {
len = stbi__get8(s);
if (len == 128) {
// No-op.
} else if (len < 128) {
// Copy next len+1 bytes literally.
len++;
if (len > nleft) return 0; // corrupt data
count += len;
while (len) {
*p = stbi__get8(s);
p += 4;
len--;
}
} else if (len > 128) {
stbi_uc val;
// Next -len+1 bytes in the dest are replicated from next source byte.
// (Interpret len as a negative 8-bit int.)
len = 257 - len;
if (len > nleft) return 0; // corrupt data
val = stbi__get8(s);
count += len;
while (len) {
*p = val;
p += 4;
len--;
}
}
}
return 1;
}
static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
{
int pixelCount;
int channelCount, compression;
int channel, i;
int bitdepth;
int w,h;
stbi_uc *out;
STBI_NOTUSED(ri);
// Check identifier
if (stbi__get32be(s) != 0x38425053) // "8BPS"
return stbi__errpuc("not PSD", "Corrupt PSD image");
// Check file type version.
if (stbi__get16be(s) != 1)
return stbi__errpuc("wrong version", "Unsupported version of PSD image");
// Skip 6 reserved bytes.
stbi__skip(s, 6 );
// Read the number of channels (R, G, B, A, etc).
channelCount = stbi__get16be(s);
if (channelCount < 0 || channelCount > 16)
return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
// Read the rows and columns of the image.
h = stbi__get32be(s);
w = stbi__get32be(s);
if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
// Make sure the depth is 8 bits.
bitdepth = stbi__get16be(s);
if (bitdepth != 8 && bitdepth != 16)
return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
// Make sure the color mode is RGB.
// Valid options are:
// 0: Bitmap
// 1: Grayscale
// 2: Indexed color
// 3: RGB color
// 4: CMYK color
// 7: Multichannel
// 8: Duotone
// 9: Lab color
if (stbi__get16be(s) != 3)
return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
// Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)
stbi__skip(s,stbi__get32be(s) );
// Skip the image resources. (resolution, pen tool paths, etc)
stbi__skip(s, stbi__get32be(s) );
// Skip the reserved data.
stbi__skip(s, stbi__get32be(s) );
// Find out if the data is compressed.
// Known values:
// 0: no compression
// 1: RLE compressed
compression = stbi__get16be(s);
if (compression > 1)
return stbi__errpuc("bad compression", "PSD has an unknown compression format");
// Check size
if (!stbi__mad3sizes_valid(4, w, h, 0))
return stbi__errpuc("too large", "Corrupt PSD");
// Create the destination image.
if (!compression && bitdepth == 16 && bpc == 16) {
out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
ri->bits_per_channel = 16;
} else
out = (stbi_uc *) stbi__malloc(4 * w*h);
if (!out) return stbi__errpuc("outofmem", "Out of memory");
pixelCount = w*h;
// Initialize the data to zero.
//memset( out, 0, pixelCount * 4 );
// Finally, the image data.
if (compression) {
// RLE as used by .PSD and .TIFF
// Loop until you get the number of unpacked bytes you are expecting:
// Read the next source byte into n.
// If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
// Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
// Else if n is 128, noop.
// Endloop
// The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
// which we're going to just skip.
stbi__skip(s, h * channelCount * 2 );
// Read the RLE data by channel.
for (channel = 0; channel < 4; channel++) {
stbi_uc *p;
p = out+channel;
if (channel >= channelCount) {
// Fill this channel with default data.
for (i = 0; i < pixelCount; i++, p += 4)
*p = (channel == 3 ? 255 : 0);
} else {
// Read the RLE data.
if (!stbi__psd_decode_rle(s, p, pixelCount)) {
STBI_FREE(out);
return stbi__errpuc("corrupt", "bad RLE data");
}
}
}
} else {
// We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
// where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
// Read the data by channel.
for (channel = 0; channel < 4; channel++) {
if (channel >= channelCount) {
// Fill this channel with default data.
if (bitdepth == 16 && bpc == 16) {
stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
stbi__uint16 val = channel == 3 ? 65535 : 0;
for (i = 0; i < pixelCount; i++, q += 4)
*q = val;
} else {
stbi_uc *p = out+channel;
stbi_uc val = channel == 3 ? 255 : 0;
for (i = 0; i < pixelCount; i++, p += 4)
*p = val;
}
} else {
if (ri->bits_per_channel == 16) { // output bpc
stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
for (i = 0; i < pixelCount; i++, q += 4)
*q = (stbi__uint16) stbi__get16be(s);
} else {
stbi_uc *p = out+channel;
if (bitdepth == 16) { // input bpc
for (i = 0; i < pixelCount; i++, p += 4)
*p = (stbi_uc) (stbi__get16be(s) >> 8);
} else {
for (i = 0; i < pixelCount; i++, p += 4)
*p = stbi__get8(s);
}
}
}
}
}
// remove weird white matte from PSD
if (channelCount >= 4) {
if (ri->bits_per_channel == 16) {
for (i=0; i < w*h; ++i) {
stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
if (pixel[3] != 0 && pixel[3] != 65535) {
float a = pixel[3] / 65535.0f;
float ra = 1.0f / a;
float inv_a = 65535.0f * (1 - ra);
pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
}
}
} else {
for (i=0; i < w*h; ++i) {
unsigned char *pixel = out + 4*i;
if (pixel[3] != 0 && pixel[3] != 255) {
float a = pixel[3] / 255.0f;
float ra = 1.0f / a;
float inv_a = 255.0f * (1 - ra);
pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
}
}
}
}
// convert to desired output format
if (req_comp && req_comp != 4) {
if (ri->bits_per_channel == 16)
out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
else
out = stbi__convert_format(out, 4, req_comp, w, h);
if (out == NULL) return out; // stbi__convert_format frees input on failure
}
if (comp) *comp = 4;
*y = h;
*x = w;
return out;
}
#endif
// *************************************************************************************************
// Softimage PIC loader
// by Tom Seddon
//
// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
#ifndef STBI_NO_PIC
static int stbi__pic_is4(stbi__context *s,const char *str)
{
int i;
for (i=0; i<4; ++i)
if (stbi__get8(s) != (stbi_uc)str[i])
return 0;
return 1;
}
static int stbi__pic_test_core(stbi__context *s)
{
int i;
if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
return 0;
for(i=0;i<84;++i)
stbi__get8(s);
if (!stbi__pic_is4(s,"PICT"))
return 0;
return 1;
}
typedef struct
{
stbi_uc size,type,channel;
} stbi__pic_packet;
static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
{
int mask=0x80, i;
for (i=0; i<4; ++i, mask>>=1) {
if (channel & mask) {
if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
dest[i]=stbi__get8(s);
}
}
return dest;
}
static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
{
int mask=0x80,i;
for (i=0;i<4; ++i, mask>>=1)
if (channel&mask)
dest[i]=src[i];
}
static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
{
int act_comp=0,num_packets=0,y,chained;
stbi__pic_packet packets[10];
// this will (should...) cater for even some bizarre stuff like having data
// for the same channel in multiple packets.
do {
stbi__pic_packet *packet;
if (num_packets==sizeof(packets)/sizeof(packets[0]))
return stbi__errpuc("bad format","too many packets");
packet = &packets[num_packets++];
chained = stbi__get8(s);
packet->size = stbi__get8(s);
packet->type = stbi__get8(s);
packet->channel = stbi__get8(s);
act_comp |= packet->channel;
if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)");
if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp");
} while (chained);
*comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
for(y=0; y<height; ++y) {
int packet_idx;
for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
stbi__pic_packet *packet = &packets[packet_idx];
stbi_uc *dest = result+y*width*4;
switch (packet->type) {
default:
return stbi__errpuc("bad format","packet has bad compression type");
case 0: {//uncompressed
int x;
for(x=0;x<width;++x, dest+=4)
if (!stbi__readval(s,packet->channel,dest))
return 0;
break;
}
case 1://Pure RLE
{
int left=width, i;
while (left>0) {
stbi_uc count,value[4];
count=stbi__get8(s);
if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)");
if (count > left)
count = (stbi_uc) left;
if (!stbi__readval(s,packet->channel,value)) return 0;
for(i=0; i<count; ++i,dest+=4)
stbi__copyval(packet->channel,dest,value);
left -= count;
}
}
break;
case 2: {//Mixed RLE
int left=width;
while (left>0) {
int count = stbi__get8(s), i;
if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)");
if (count >= 128) { // Repeated
stbi_uc value[4];
if (count==128)
count = stbi__get16be(s);
else
count -= 127;
if (count > left)
return stbi__errpuc("bad file","scanline overrun");
if (!stbi__readval(s,packet->channel,value))
return 0;
for(i=0;i<count;++i, dest += 4)
stbi__copyval(packet->channel,dest,value);
} else { // Raw
++count;
if (count>left) return stbi__errpuc("bad file","scanline overrun");
for(i=0;i<count;++i, dest+=4)
if (!stbi__readval(s,packet->channel,dest))
return 0;
}
left-=count;
}
break;
}
}
}
}
return result;
}
static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
{
stbi_uc *result;
int i, x,y, internal_comp;
STBI_NOTUSED(ri);
if (!comp) comp = &internal_comp;
for (i=0; i<92; ++i)
stbi__get8(s);
x = stbi__get16be(s);
y = stbi__get16be(s);
if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)");
if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
stbi__get32be(s); //skip `ratio'
stbi__get16be(s); //skip `fields'
stbi__get16be(s); //skip `pad'
// intermediate buffer is RGBA
result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
memset(result, 0xff, x*y*4);
if (!stbi__pic_load_core(s,x,y,comp, result)) {
STBI_FREE(result);
result=0;
}
*px = x;
*py = y;
if (req_comp == 0) req_comp = *comp;
result=stbi__convert_format(result,4,req_comp,x,y);
return result;
}
static int stbi__pic_test(stbi__context *s)
{
int r = stbi__pic_test_core(s);
stbi__rewind(s);
return r;
}
#endif
// *************************************************************************************************
// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
#ifndef STBI_NO_GIF
typedef struct
{
stbi__int16 prefix;
stbi_uc first;
stbi_uc suffix;
} stbi__gif_lzw;
typedef struct
{
int w,h;
stbi_uc *out; // output buffer (always 4 components)
stbi_uc *background; // The current "background" as far as a gif is concerned
stbi_uc *history;
int flags, bgindex, ratio, transparent, eflags;
stbi_uc pal[256][4];
stbi_uc lpal[256][4];
stbi__gif_lzw codes[8192];
stbi_uc *color_table;
int parse, step;
int lflags;
int start_x, start_y;
int max_x, max_y;
int cur_x, cur_y;
int line_size;
int delay;
} stbi__gif;
static int stbi__gif_test_raw(stbi__context *s)
{
int sz;
if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
sz = stbi__get8(s);
if (sz != '9' && sz != '7') return 0;
if (stbi__get8(s) != 'a') return 0;
return 1;
}
static int stbi__gif_test(stbi__context *s)
{
int r = stbi__gif_test_raw(s);
stbi__rewind(s);
return r;
}
static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
{
int i;
for (i=0; i < num_entries; ++i) {
pal[i][2] = stbi__get8(s);
pal[i][1] = stbi__get8(s);
pal[i][0] = stbi__get8(s);
pal[i][3] = transp == i ? 0 : 255;
}
}
static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
{
stbi_uc version;
if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
return stbi__err("not GIF", "Corrupt GIF");
version = stbi__get8(s);
if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF");
if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF");
stbi__g_failure_reason = "";
g->w = stbi__get16le(s);
g->h = stbi__get16le(s);
g->flags = stbi__get8(s);
g->bgindex = stbi__get8(s);
g->ratio = stbi__get8(s);
g->transparent = -1;
if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments
if (is_info) return 1;
if (g->flags & 0x80)
stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
return 1;
}
static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
{
stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
if (!stbi__gif_header(s, g, comp, 1)) {
STBI_FREE(g);
stbi__rewind( s );
return 0;
}
if (x) *x = g->w;
if (y) *y = g->h;
STBI_FREE(g);
return 1;
}
static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
{
stbi_uc *p, *c;
int idx;
// recurse to decode the prefixes, since the linked-list is backwards,
// and working backwards through an interleaved image would be nasty
if (g->codes[code].prefix >= 0)
stbi__out_gif_code(g, g->codes[code].prefix);
if (g->cur_y >= g->max_y) return;
idx = g->cur_x + g->cur_y;
p = &g->out[idx];
g->history[idx / 4] = 1;
c = &g->color_table[g->codes[code].suffix * 4];
if (c[3] > 128) { // don't render transparent pixels;
p[0] = c[2];
p[1] = c[1];
p[2] = c[0];
p[3] = c[3];
}
g->cur_x += 4;
if (g->cur_x >= g->max_x) {
g->cur_x = g->start_x;
g->cur_y += g->step;
while (g->cur_y >= g->max_y && g->parse > 0) {
g->step = (1 << g->parse) * g->line_size;
g->cur_y = g->start_y + (g->step >> 1);
--g->parse;
}
}
}
static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
{
stbi_uc lzw_cs;
stbi__int32 len, init_code;
stbi__uint32 first;
stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
stbi__gif_lzw *p;
lzw_cs = stbi__get8(s);
if (lzw_cs > 12) return NULL;
clear = 1 << lzw_cs;
first = 1;
codesize = lzw_cs + 1;
codemask = (1 << codesize) - 1;
bits = 0;
valid_bits = 0;
for (init_code = 0; init_code < clear; init_code++) {
g->codes[init_code].prefix = -1;
g->codes[init_code].first = (stbi_uc) init_code;
g->codes[init_code].suffix = (stbi_uc) init_code;
}
// support no starting clear code
avail = clear+2;
oldcode = -1;
len = 0;
for(;;) {
if (valid_bits < codesize) {
if (len == 0) {
len = stbi__get8(s); // start new block
if (len == 0)
return g->out;
}
--len;
bits |= (stbi__int32) stbi__get8(s) << valid_bits;
valid_bits += 8;
} else {
stbi__int32 code = bits & codemask;
bits >>= codesize;
valid_bits -= codesize;
// @OPTIMIZE: is there some way we can accelerate the non-clear path?
if (code == clear) { // clear code
codesize = lzw_cs + 1;
codemask = (1 << codesize) - 1;
avail = clear + 2;
oldcode = -1;
first = 0;
} else if (code == clear + 1) { // end of stream code
stbi__skip(s, len);
while ((len = stbi__get8(s)) > 0)
stbi__skip(s,len);
return g->out;
} else if (code <= avail) {
if (first) {
return stbi__errpuc("no clear code", "Corrupt GIF");
}
if (oldcode >= 0) {
p = &g->codes[avail++];
if (avail > 8192) {
return stbi__errpuc("too many codes", "Corrupt GIF");
}
p->prefix = (stbi__int16) oldcode;
p->first = g->codes[oldcode].first;
p->suffix = (code == avail) ? p->first : g->codes[code].first;
} else if (code == avail)
return stbi__errpuc("illegal code in raster", "Corrupt GIF");
stbi__out_gif_code(g, (stbi__uint16) code);
if ((avail & codemask) == 0 && avail <= 0x0FFF) {
codesize++;
codemask = (1 << codesize) - 1;
}
oldcode = code;
} else {
return stbi__errpuc("illegal code in raster", "Corrupt GIF");
}
}
}
}
// this function is designed to support animated gifs, although stb_image doesn't support it
// two back is the image from two frames ago, used for a very specific disposal format
static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
{
int dispose;
int first_frame;
int pi;
int pcount;
STBI_NOTUSED(req_comp);
// on first frame, any non-written pixels get the background colour (non-transparent)
first_frame = 0;
if (g->out == 0) {
if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
return stbi__errpuc("too large", "GIF image is too large");
pcount = g->w * g->h;
g->out = (stbi_uc *) stbi__malloc(4 * pcount);
g->background = (stbi_uc *) stbi__malloc(4 * pcount);
g->history = (stbi_uc *) stbi__malloc(pcount);
if (!g->out || !g->background || !g->history)
return stbi__errpuc("outofmem", "Out of memory");
// image is treated as "transparent" at the start - ie, nothing overwrites the current background;
// background colour is only used for pixels that are not rendered first frame, after that "background"
// color refers to the color that was there the previous frame.
memset(g->out, 0x00, 4 * pcount);
memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
memset(g->history, 0x00, pcount); // pixels that were affected previous frame
first_frame = 1;
} else {
// second frame - how do we dispose of the previous one?
dispose = (g->eflags & 0x1C) >> 2;
pcount = g->w * g->h;
if ((dispose == 3) && (two_back == 0)) {
dispose = 2; // if I don't have an image to revert back to, default to the old background
}
if (dispose == 3) { // use previous graphic
for (pi = 0; pi < pcount; ++pi) {
if (g->history[pi]) {
memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
}
}
} else if (dispose == 2) {
// restore what was changed last frame to background before that frame;
for (pi = 0; pi < pcount; ++pi) {
if (g->history[pi]) {
memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
}
}
} else {
// This is a non-disposal case eithe way, so just
// leave the pixels as is, and they will become the new background
// 1: do not dispose
// 0: not specified.
}
// background is what out is after the undoing of the previou frame;
memcpy( g->background, g->out, 4 * g->w * g->h );
}
// clear my history;
memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame
for (;;) {
int tag = stbi__get8(s);
switch (tag) {
case 0x2C: /* Image Descriptor */
{
stbi__int32 x, y, w, h;
stbi_uc *o;
x = stbi__get16le(s);
y = stbi__get16le(s);
w = stbi__get16le(s);
h = stbi__get16le(s);
if (((x + w) > (g->w)) || ((y + h) > (g->h)))
return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
g->line_size = g->w * 4;
g->start_x = x * 4;
g->start_y = y * g->line_size;
g->max_x = g->start_x + w * 4;
g->max_y = g->start_y + h * g->line_size;
g->cur_x = g->start_x;
g->cur_y = g->start_y;
// if the width of the specified rectangle is 0, that means
// we may not see *any* pixels or the image is malformed;
// to make sure this is caught, move the current y down to
// max_y (which is what out_gif_code checks).
if (w == 0)
g->cur_y = g->max_y;
g->lflags = stbi__get8(s);
if (g->lflags & 0x40) {
g->step = 8 * g->line_size; // first interlaced spacing
g->parse = 3;
} else {
g->step = g->line_size;
g->parse = 0;
}
if (g->lflags & 0x80) {
stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
g->color_table = (stbi_uc *) g->lpal;
} else if (g->flags & 0x80) {
g->color_table = (stbi_uc *) g->pal;
} else
return stbi__errpuc("missing color table", "Corrupt GIF");
o = stbi__process_gif_raster(s, g);
if (!o) return NULL;
// if this was the first frame,
pcount = g->w * g->h;
if (first_frame && (g->bgindex > 0)) {
// if first frame, any pixel not drawn to gets the background color
for (pi = 0; pi < pcount; ++pi) {
if (g->history[pi] == 0) {
g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
}
}
}
return o;
}
case 0x21: // Comment Extension.
{
int len;
int ext = stbi__get8(s);
if (ext == 0xF9) { // Graphic Control Extension.
len = stbi__get8(s);
if (len == 4) {
g->eflags = stbi__get8(s);
g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
// unset old transparent
if (g->transparent >= 0) {
g->pal[g->transparent][3] = 255;
}
if (g->eflags & 0x01) {
g->transparent = stbi__get8(s);
if (g->transparent >= 0) {
g->pal[g->transparent][3] = 0;
}
} else {
// don't need transparent
stbi__skip(s, 1);
g->transparent = -1;
}
} else {
stbi__skip(s, len);
break;
}
}
while ((len = stbi__get8(s)) != 0) {
stbi__skip(s, len);
}
break;
}
case 0x3B: // gif stream termination code
return (stbi_uc *) s; // using '1' causes warning on some compilers
default:
return stbi__errpuc("unknown code", "Corrupt GIF");
}
}
}
static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
{
if (stbi__gif_test(s)) {
int layers = 0;
stbi_uc *u = 0;
stbi_uc *out = 0;
stbi_uc *two_back = 0;
stbi__gif g;
int stride;
int out_size = 0;
int delays_size = 0;
memset(&g, 0, sizeof(g));
if (delays) {
*delays = 0;
}
do {
u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
if (u) {
*x = g.w;
*y = g.h;
++layers;
stride = g.w * g.h * 4;
if (out) {
void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );
if (NULL == tmp) {
STBI_FREE(g.out);
STBI_FREE(g.history);
STBI_FREE(g.background);
return stbi__errpuc("outofmem", "Out of memory");
}
else {
out = (stbi_uc*) tmp;
out_size = layers * stride;
}
if (delays) {
*delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );
delays_size = layers * sizeof(int);
}
} else {
out = (stbi_uc*)stbi__malloc( layers * stride );
out_size = layers * stride;
if (delays) {
*delays = (int*) stbi__malloc( layers * sizeof(int) );
delays_size = layers * sizeof(int);
}
}
memcpy( out + ((layers - 1) * stride), u, stride );
if (layers >= 2) {
two_back = out - 2 * stride;
}
if (delays) {
(*delays)[layers - 1U] = g.delay;
}
}
} while (u != 0);
// free temp buffer;
STBI_FREE(g.out);
STBI_FREE(g.history);
STBI_FREE(g.background);
// do the final conversion after loading everything;
if (req_comp && req_comp != 4)
out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
*z = layers;
return out;
} else {
return stbi__errpuc("not GIF", "Image was not as a gif type.");
}
}
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
stbi_uc *u = 0;
stbi__gif g;
memset(&g, 0, sizeof(g));
STBI_NOTUSED(ri);
u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
if (u) {
*x = g.w;
*y = g.h;
// moved conversion to after successful load so that the same
// can be done for multiple frames.
if (req_comp && req_comp != 4)
u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
} else if (g.out) {
// if there was an error and we allocated an image buffer, free it!
STBI_FREE(g.out);
}
// free buffers needed for multiple frame loading;
STBI_FREE(g.history);
STBI_FREE(g.background);
return u;
}
static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
{
return stbi__gif_info_raw(s,x,y,comp);
}
#endif
// *************************************************************************************************
// Radiance RGBE HDR loader
// originally by Nicolas Schulz
#ifndef STBI_NO_HDR
static int stbi__hdr_test_core(stbi__context *s, const char *signature)
{
int i;
for (i=0; signature[i]; ++i)
if (stbi__get8(s) != signature[i])
return 0;
stbi__rewind(s);
return 1;
}
static int stbi__hdr_test(stbi__context* s)
{
int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
stbi__rewind(s);
if(!r) {
r = stbi__hdr_test_core(s, "#?RGBE\n");
stbi__rewind(s);
}
return r;
}
#define STBI__HDR_BUFLEN 1024
static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
{
int len=0;
char c = '\0';
c = (char) stbi__get8(z);
while (!stbi__at_eof(z) && c != '\n') {
buffer[len++] = c;
if (len == STBI__HDR_BUFLEN-1) {
// flush to end of line
while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
;
break;
}
c = (char) stbi__get8(z);
}
buffer[len] = 0;
return buffer;
}
static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
{
if ( input[3] != 0 ) {
float f1;
// Exponent
f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
if (req_comp <= 2)
output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
else {
output[0] = input[0] * f1;
output[1] = input[1] * f1;
output[2] = input[2] * f1;
}
if (req_comp == 2) output[1] = 1;
if (req_comp == 4) output[3] = 1;
} else {
switch (req_comp) {
case 4: output[3] = 1; /* fallthrough */
case 3: output[0] = output[1] = output[2] = 0;
break;
case 2: output[1] = 1; /* fallthrough */
case 1: output[0] = 0;
break;
}
}
}
static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
char buffer[STBI__HDR_BUFLEN];
char *token;
int valid = 0;
int width, height;
stbi_uc *scanline;
float *hdr_data;
int len;
unsigned char count, value;
int i, j, k, c1,c2, z;
const char *headerToken;
STBI_NOTUSED(ri);
// Check identifier
headerToken = stbi__hdr_gettoken(s,buffer);
if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
return stbi__errpf("not HDR", "Corrupt HDR image");
// Parse header
for(;;) {
token = stbi__hdr_gettoken(s,buffer);
if (token[0] == 0) break;
if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
}
if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format");
// Parse width and height
// can't use sscanf() if we're not using stdio!
token = stbi__hdr_gettoken(s,buffer);
if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
token += 3;
height = (int) strtol(token, &token, 10);
while (*token == ' ') ++token;
if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
token += 3;
width = (int) strtol(token, NULL, 10);
if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
*x = width;
*y = height;
if (comp) *comp = 3;
if (req_comp == 0) req_comp = 3;
if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
return stbi__errpf("too large", "HDR image is too large");
// Read data
hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
if (!hdr_data)
return stbi__errpf("outofmem", "Out of memory");
// Load image data
// image data is stored as some number of sca
if ( width < 8 || width >= 32768) {
// Read flat data
for (j=0; j < height; ++j) {
for (i=0; i < width; ++i) {
stbi_uc rgbe[4];
main_decode_loop:
stbi__getn(s, rgbe, 4);
stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
}
}
} else {
// Read RLE-encoded data
scanline = NULL;
for (j = 0; j < height; ++j) {
c1 = stbi__get8(s);
c2 = stbi__get8(s);
len = stbi__get8(s);
if (c1 != 2 || c2 != 2 || (len & 0x80)) {
// not run-length encoded, so we have to actually use THIS data as a decoded
// pixel (note this can't be a valid pixel--one of RGB must be >= 128)
stbi_uc rgbe[4];
rgbe[0] = (stbi_uc) c1;
rgbe[1] = (stbi_uc) c2;
rgbe[2] = (stbi_uc) len;
rgbe[3] = (stbi_uc) stbi__get8(s);
stbi__hdr_convert(hdr_data, rgbe, req_comp);
i = 1;
j = 0;
STBI_FREE(scanline);
goto main_decode_loop; // yes, this makes no sense
}
len <<= 8;
len |= stbi__get8(s);
if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
if (scanline == NULL) {
scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
if (!scanline) {
STBI_FREE(hdr_data);
return stbi__errpf("outofmem", "Out of memory");
}
}
for (k = 0; k < 4; ++k) {
int nleft;
i = 0;
while ((nleft = width - i) > 0) {
count = stbi__get8(s);
if (count > 128) {
// Run
value = stbi__get8(s);
count -= 128;
if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
for (z = 0; z < count; ++z)
scanline[i++ * 4 + k] = value;
} else {
// Dump
if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
for (z = 0; z < count; ++z)
scanline[i++ * 4 + k] = stbi__get8(s);
}
}
}
for (i=0; i < width; ++i)
stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
}
if (scanline)
STBI_FREE(scanline);
}
return hdr_data;
}
static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
{
char buffer[STBI__HDR_BUFLEN];
char *token;
int valid = 0;
int dummy;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (stbi__hdr_test(s) == 0) {
stbi__rewind( s );
return 0;
}
for(;;) {
token = stbi__hdr_gettoken(s,buffer);
if (token[0] == 0) break;
if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
}
if (!valid) {
stbi__rewind( s );
return 0;
}
token = stbi__hdr_gettoken(s,buffer);
if (strncmp(token, "-Y ", 3)) {
stbi__rewind( s );
return 0;
}
token += 3;
*y = (int) strtol(token, &token, 10);
while (*token == ' ') ++token;
if (strncmp(token, "+X ", 3)) {
stbi__rewind( s );
return 0;
}
token += 3;
*x = (int) strtol(token, NULL, 10);
*comp = 3;
return 1;
}
#endif // STBI_NO_HDR
#ifndef STBI_NO_BMP
static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
{
void *p;
stbi__bmp_data info;
info.all_a = 255;
p = stbi__bmp_parse_header(s, &info);
stbi__rewind( s );
if (p == NULL)
return 0;
if (x) *x = s->img_x;
if (y) *y = s->img_y;
if (comp) {
if (info.bpp == 24 && info.ma == 0xff000000)
*comp = 3;
else
*comp = info.ma ? 4 : 3;
}
return 1;
}
#endif
#ifndef STBI_NO_PSD
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
{
int channelCount, dummy, depth;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (stbi__get32be(s) != 0x38425053) {
stbi__rewind( s );
return 0;
}
if (stbi__get16be(s) != 1) {
stbi__rewind( s );
return 0;
}
stbi__skip(s, 6);
channelCount = stbi__get16be(s);
if (channelCount < 0 || channelCount > 16) {
stbi__rewind( s );
return 0;
}
*y = stbi__get32be(s);
*x = stbi__get32be(s);
depth = stbi__get16be(s);
if (depth != 8 && depth != 16) {
stbi__rewind( s );
return 0;
}
if (stbi__get16be(s) != 3) {
stbi__rewind( s );
return 0;
}
*comp = 4;
return 1;
}
static int stbi__psd_is16(stbi__context *s)
{
int channelCount, depth;
if (stbi__get32be(s) != 0x38425053) {
stbi__rewind( s );
return 0;
}
if (stbi__get16be(s) != 1) {
stbi__rewind( s );
return 0;
}
stbi__skip(s, 6);
channelCount = stbi__get16be(s);
if (channelCount < 0 || channelCount > 16) {
stbi__rewind( s );
return 0;
}
(void) stbi__get32be(s);
(void) stbi__get32be(s);
depth = stbi__get16be(s);
if (depth != 16) {
stbi__rewind( s );
return 0;
}
return 1;
}
#endif
#ifndef STBI_NO_PIC
static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
{
int act_comp=0,num_packets=0,chained,dummy;
stbi__pic_packet packets[10];
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
stbi__rewind(s);
return 0;
}
stbi__skip(s, 88);
*x = stbi__get16be(s);
*y = stbi__get16be(s);
if (stbi__at_eof(s)) {
stbi__rewind( s);
return 0;
}
if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
stbi__rewind( s );
return 0;
}
stbi__skip(s, 8);
do {
stbi__pic_packet *packet;
if (num_packets==sizeof(packets)/sizeof(packets[0]))
return 0;
packet = &packets[num_packets++];
chained = stbi__get8(s);
packet->size = stbi__get8(s);
packet->type = stbi__get8(s);
packet->channel = stbi__get8(s);
act_comp |= packet->channel;
if (stbi__at_eof(s)) {
stbi__rewind( s );
return 0;
}
if (packet->size != 8) {
stbi__rewind( s );
return 0;
}
} while (chained);
*comp = (act_comp & 0x10 ? 4 : 3);
return 1;
}
#endif
// *************************************************************************************************
// Portable Gray Map and Portable Pixel Map loader
// by Ken Miller
//
// PGM: http://netpbm.sourceforge.net/doc/pgm.html
// PPM: http://netpbm.sourceforge.net/doc/ppm.html
//
// Known limitations:
// Does not support comments in the header section
// Does not support ASCII image data (formats P2 and P3)
// Does not support 16-bit-per-channel
#ifndef STBI_NO_PNM
static int stbi__pnm_test(stbi__context *s)
{
char p, t;
p = (char) stbi__get8(s);
t = (char) stbi__get8(s);
if (p != 'P' || (t != '5' && t != '6')) {
stbi__rewind( s );
return 0;
}
return 1;
}
static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
stbi_uc *out;
STBI_NOTUSED(ri);
if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
return 0;
if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
*x = s->img_x;
*y = s->img_y;
if (comp) *comp = s->img_n;
if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0))
return stbi__errpuc("too large", "PNM too large");
out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0);
if (!out) return stbi__errpuc("outofmem", "Out of memory");
stbi__getn(s, out, s->img_n * s->img_x * s->img_y);
if (req_comp && req_comp != s->img_n) {
out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
if (out == NULL) return out; // stbi__convert_format frees input on failure
}
return out;
}
static int stbi__pnm_isspace(char c)
{
return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
}
static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)
{
for (;;) {
while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
*c = (char) stbi__get8(s);
if (stbi__at_eof(s) || *c != '#')
break;
while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
*c = (char) stbi__get8(s);
}
}
static int stbi__pnm_isdigit(char c)
{
return c >= '0' && c <= '9';
}
static int stbi__pnm_getinteger(stbi__context *s, char *c)
{
int value = 0;
while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
value = value*10 + (*c - '0');
*c = (char) stbi__get8(s);
}
return value;
}
static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
{
int maxv, dummy;
char c, p, t;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
stbi__rewind(s);
// Get identifier
p = (char) stbi__get8(s);
t = (char) stbi__get8(s);
if (p != 'P' || (t != '5' && t != '6')) {
stbi__rewind(s);
return 0;
}
*comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm
c = (char) stbi__get8(s);
stbi__pnm_skip_whitespace(s, &c);
*x = stbi__pnm_getinteger(s, &c); // read width
stbi__pnm_skip_whitespace(s, &c);
*y = stbi__pnm_getinteger(s, &c); // read height
stbi__pnm_skip_whitespace(s, &c);
maxv = stbi__pnm_getinteger(s, &c); // read max value
if (maxv > 255)
return stbi__err("max value > 255", "PPM image not 8-bit");
else
return 1;
}
#endif
static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
{
#ifndef STBI_NO_JPEG
if (stbi__jpeg_info(s, x, y, comp)) return 1;
#endif
#ifndef STBI_NO_PNG
if (stbi__png_info(s, x, y, comp)) return 1;
#endif
#ifndef STBI_NO_GIF
if (stbi__gif_info(s, x, y, comp)) return 1;
#endif
#ifndef STBI_NO_BMP
if (stbi__bmp_info(s, x, y, comp)) return 1;
#endif
#ifndef STBI_NO_PSD
if (stbi__psd_info(s, x, y, comp)) return 1;
#endif
#ifndef STBI_NO_PIC
if (stbi__pic_info(s, x, y, comp)) return 1;
#endif
#ifndef STBI_NO_PNM
if (stbi__pnm_info(s, x, y, comp)) return 1;
#endif
#ifndef STBI_NO_HDR
if (stbi__hdr_info(s, x, y, comp)) return 1;
#endif
// test tga last because it's a crappy test!
#ifndef STBI_NO_TGA
if (stbi__tga_info(s, x, y, comp))
return 1;
#endif
return stbi__err("unknown image type", "Image not of any known type, or corrupt");
}
static int stbi__is_16_main(stbi__context *s)
{
#ifndef STBI_NO_PNG
if (stbi__png_is16(s)) return 1;
#endif
#ifndef STBI_NO_PSD
if (stbi__psd_is16(s)) return 1;
#endif
return 0;
}
#ifndef STBI_NO_STDIO
STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
{
FILE *f = stbi__fopen(filename, "rb");
int result;
if (!f) return stbi__err("can't fopen", "Unable to open file");
result = stbi_info_from_file(f, x, y, comp);
fclose(f);
return result;
}
STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
{
int r;
stbi__context s;
long pos = ftell(f);
stbi__start_file(&s, f);
r = stbi__info_main(&s,x,y,comp);
fseek(f,pos,SEEK_SET);
return r;
}
STBIDEF int stbi_is_16_bit(char const *filename)
{
FILE *f = stbi__fopen(filename, "rb");
int result;
if (!f) return stbi__err("can't fopen", "Unable to open file");
result = stbi_is_16_bit_from_file(f);
fclose(f);
return result;
}
STBIDEF int stbi_is_16_bit_from_file(FILE *f)
{
int r;
stbi__context s;
long pos = ftell(f);
stbi__start_file(&s, f);
r = stbi__is_16_main(&s);
fseek(f,pos,SEEK_SET);
return r;
}
#endif // !STBI_NO_STDIO
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__info_main(&s,x,y,comp);
}
STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
return stbi__info_main(&s,x,y,comp);
}
STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__is_16_main(&s);
}
STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
return stbi__is_16_main(&s);
}
#endif // STB_IMAGE_IMPLEMENTATION
/*
revision history:
2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
2.19 (2018-02-11) fix warning
2.18 (2018-01-30) fix warnings
2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
1-bit BMP
*_is_16_bit api
avoid warnings
2.16 (2017-07-23) all functions have 16-bit variants;
STBI_NO_STDIO works again;
compilation fixes;
fix rounding in unpremultiply;
optimize vertical flip;
disable raw_len validation;
documentation fixes
2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
warning fixes; disable run-time SSE detection on gcc;
uniform handling of optional "return" values;
thread-safe initialization of zlib tables
2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
2.13 (2016-11-29) add 16-bit API, only supported for PNG right now
2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
2.11 (2016-04-02) allocate large structures on the stack
remove white matting for transparent PSD
fix reported channel count for PNG & BMP
re-enable SSE2 in non-gcc 64-bit
support RGB-formatted JPEG
read 16-bit PNGs (only as 8-bit)
2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
2.09 (2016-01-16) allow comments in PNM files
16-bit-per-pixel TGA (not bit-per-component)
info() for TGA could break due to .hdr handling
info() for BMP to shares code instead of sloppy parse
can use STBI_REALLOC_SIZED if allocator doesn't support realloc
code cleanup
2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
2.07 (2015-09-13) fix compiler warnings
partial animated GIF support
limited 16-bpc PSD support
#ifdef unused functions
bug with < 92 byte PIC,PNM,HDR,TGA
2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value
2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning
2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit
2.03 (2015-04-12) extra corruption checking (mmozeiko)
stbi_set_flip_vertically_on_load (nguillemot)
fix NEON support; fix mingw support
2.02 (2015-01-19) fix incorrect assert, fix warning
2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
progressive JPEG (stb)
PGM/PPM support (Ken Miller)
STBI_MALLOC,STBI_REALLOC,STBI_FREE
GIF bugfix -- seemingly never worked
STBI_NO_*, STBI_ONLY_*
1.48 (2014-12-14) fix incorrectly-named assert()
1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
optimize PNG (ryg)
fix bug in interlaced PNG with user-specified channel count (stb)
1.46 (2014-08-26)
fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
1.45 (2014-08-16)
fix MSVC-ARM internal compiler error by wrapping malloc
1.44 (2014-08-07)
various warning fixes from Ronny Chevalier
1.43 (2014-07-15)
fix MSVC-only compiler problem in code changed in 1.42
1.42 (2014-07-09)
don't define _CRT_SECURE_NO_WARNINGS (affects user code)
fixes to stbi__cleanup_jpeg path
added STBI_ASSERT to avoid requiring assert.h
1.41 (2014-06-25)
fix search&replace from 1.36 that messed up comments/error messages
1.40 (2014-06-22)
fix gcc struct-initialization warning
1.39 (2014-06-15)
fix to TGA optimization when req_comp != number of components in TGA;
fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
add support for BMP version 5 (more ignored fields)
1.38 (2014-06-06)
suppress MSVC warnings on integer casts truncating values
fix accidental rename of 'skip' field of I/O
1.37 (2014-06-04)
remove duplicate typedef
1.36 (2014-06-03)
convert to header file single-file library
if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
1.35 (2014-05-27)
various warnings
fix broken STBI_SIMD path
fix bug where stbi_load_from_file no longer left file pointer in correct place
fix broken non-easy path for 32-bit BMP (possibly never used)
TGA optimization by Arseny Kapoulkine
1.34 (unknown)
use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
1.33 (2011-07-14)
make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
1.32 (2011-07-13)
support for "info" function for all supported filetypes (SpartanJ)
1.31 (2011-06-20)
a few more leak fixes, bug in PNG handling (SpartanJ)
1.30 (2011-06-11)
added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
removed deprecated format-specific test/load functions
removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
fix inefficiency in decoding 32-bit BMP (David Woo)
1.29 (2010-08-16)
various warning fixes from Aurelien Pocheville
1.28 (2010-08-01)
fix bug in GIF palette transparency (SpartanJ)
1.27 (2010-08-01)
cast-to-stbi_uc to fix warnings
1.26 (2010-07-24)
fix bug in file buffering for PNG reported by SpartanJ
1.25 (2010-07-17)
refix trans_data warning (Won Chun)
1.24 (2010-07-12)
perf improvements reading from files on platforms with lock-heavy fgetc()
minor perf improvements for jpeg
deprecated type-specific functions so we'll get feedback if they're needed
attempt to fix trans_data warning (Won Chun)
1.23 fixed bug in iPhone support
1.22 (2010-07-10)
removed image *writing* support
stbi_info support from Jetro Lauha
GIF support from Jean-Marc Lienher
iPhone PNG-extensions from James Brown
warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
1.21 fix use of 'stbi_uc' in header (reported by jon blow)
1.20 added support for Softimage PIC, by Tom Seddon
1.19 bug in interlaced PNG corruption check (found by ryg)
1.18 (2008-08-02)
fix a threading bug (local mutable static)
1.17 support interlaced PNG
1.16 major bugfix - stbi__convert_format converted one too many pixels
1.15 initialize some fields for thread safety
1.14 fix threadsafe conversion bug
header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
1.13 threadsafe
1.12 const qualifiers in the API
1.11 Support installable IDCT, colorspace conversion routines
1.10 Fixes for 64-bit (don't use "unsigned long")
optimized upsampling by Fabian "ryg" Giesen
1.09 Fix format-conversion for PSD code (bad global variables!)
1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz
1.07 attempt to fix C++ warning/errors again
1.06 attempt to fix C++ warning/errors again
1.05 fix TGA loading to return correct *comp and use good luminance calc
1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free
1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR
1.02 support for (subset of) HDR files, float interface for preferred access to them
1.01 fix bug: possible bug in handling right-side up bmps... not sure
fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
1.00 interface to zlib that skips zlib header
0.99 correct handling of alpha in palette
0.98 TGA loader by lonesock; dynamically add loaders (untested)
0.97 jpeg errors on too large a file; also catch another malloc failure
0.96 fix detection of invalid v value - particleman@mollyrocket forum
0.95 during header scan, seek to markers in case of padding
0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same
0.93 handle jpegtran output; verbose errors
0.92 read 4,8,16,24,32-bit BMP files of several formats
0.91 output 24-bit Windows 3.0 BMP files
0.90 fix a few more warnings; bump version number to approach 1.0
0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd
0.60 fix compiling as c++
0.59 fix warnings: merge Dave Moore's -Wall fixes
0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian
0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
0.56 fix bug: zlib uncompressed mode len vs. nlen
0.55 fix bug: restart_interval not initialized to 0
0.54 allow NULL for 'int *comp'
0.53 fix bug in png 3->4; speedup png decoding
0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments
0.51 obey req_comp requests, 1-component jpegs return as 1-component,
on 'test' only check type, not whether we support this variant
0.50 (2006-11-19)
first released version
*/
/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2017 Sean Barrett
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
*/
| 273,150 | C | 34.186268 | 209 | 0.541787 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.