-
Notifications
You must be signed in to change notification settings - Fork 503
RealityKit macOS xcode13.0 beta1
Manuel de la Pena edited this page Jul 12, 2021
·
2 revisions
#RealityKit.framework ##mandel
diff -ruN /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKit.h /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKit.h
--- /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKit.h 1969-12-31 19:00:00.000000000 -0500
+++ /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKit.h 2021-06-02 00:24:17.000000000 -0400
@@ -0,0 +1,17 @@
+#ifndef REALITYKIT_H_
+#define REALITYKIT_H_
+
+//
+// Copyright © 2021 Apple Inc. All rights reserved.
+//
+
+#ifndef __REALITYKIT_INDIRECT
+#define __REALITYKIT_INDIRECT
+#endif
+
+#import <RealityKit/RealityKitGeometryModifier.h>
+#import <RealityKit/RealityKitSurfaceShader.h>
+
+#undef __REALITYKIT_INDIRECT
+
+#endif // REALITYKIT_H_
diff -ruN /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitConfig.h /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitConfig.h
--- /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitConfig.h 1969-12-31 19:00:00.000000000 -0500
+++ /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitConfig.h 2021-06-02 00:24:17.000000000 -0400
@@ -0,0 +1,8 @@
+#ifndef REALITYKIT_CONFIG_H
+#define REALITYKIT_CONFIG_H
+
+//
+// Copyright © 2021 Apple Inc. All rights reserved.
+//
+
+#endif /* REALITYKIT_CONFIG_H */
diff -ruN /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitGeometryModifier.h /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitGeometryModifier.h
--- /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitGeometryModifier.h 1969-12-31 19:00:00.000000000 -0500
+++ /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitGeometryModifier.h 2021-06-02 00:24:17.000000000 -0400
@@ -0,0 +1,452 @@
+#ifndef REALITYKIT_GEOMETRYMODIFIER_H_
+#define REALITYKIT_GEOMETRYMODIFIER_H_
+
+//
+// Copyright © 2021 Apple Inc. All rights reserved.
+//
+#if defined(__METAL_VERSION__)
+
+#ifndef __REALITYKIT_INDIRECT
+#error "Please include <RealityKit/RealityKit.h> instead of individual files directly"
+#endif
+
+#include <RealityKit/RealityKitMaterialParameters.h>
+#include <RealityKit/RealityKitTextures.h>
+#include <RealityKit/RealityKitTypes.h>
+
+#include <metal_stdlib>
+#include <metal_types>
+
+namespace realitykit
+{
+struct geometry_parameters;
+
+namespace geometry_modifier
+{
+struct geometry_data_t;
+
+namespace api
+{
+// Uniforms
+
+RK_API float time(thread geometry_data_t &data);
+
+RK_API metal::float2 uv0_offset(thread geometry_data_t &data);
+RK_API metal::float2x2 uv0_transform(thread geometry_data_t &data);
+
+RK_API metal::float2 uv1_offset(thread geometry_data_t &data);
+RK_API metal::float2x2 uv1_transform(thread geometry_data_t &data);
+
+RK_API float4 custom_parameter(thread geometry_data_t &data);
+
+RK_API thread texture::texture_data_t &textures(thread geometry_data_t &data);
+RK_API thread material::material_constants_t &material_constants(thread geometry_data_t &data);
+
+// Transforms
+
+RK_API metal::float4x4 model_to_world(thread geometry_data_t &data);
+RK_API metal::float4x4 world_to_model(thread geometry_data_t &data);
+
+RK_API metal::float3x3 normal_to_world(thread geometry_data_t &data);
+
+RK_API metal::float4x4 model_to_view(thread geometry_data_t &data);
+
+RK_API metal::float4x4 view_to_projection(thread geometry_data_t &data);
+RK_API metal::float4x4 projection_to_view(thread geometry_data_t &data);
+
+// Geometry
+
+RK_API uint vertex_id(thread geometry_data_t &data);
+RK_API float3 position(thread geometry_data_t &data);
+
+RK_API float3 model_position_offset(thread geometry_data_t &data);
+RK_API void set_model_position_offset(float3 value, thread geometry_data_t &data);
+
+RK_API float4 color(thread geometry_data_t &data);
+RK_API void set_color(float4 value, thread geometry_data_t &data);
+
+RK_API float3 normal(thread geometry_data_t &data);
+RK_API void set_normal(float3 value, thread geometry_data_t &data);
+
+RK_API float3 bitangent(thread geometry_data_t &data);
+RK_API void set_bitangent(float3 value, thread geometry_data_t &data);
+
+RK_API float2 uv0(thread geometry_data_t &data);
+RK_API void set_uv0(float2 value, thread geometry_data_t &data);
+
+RK_API float2 uv1(thread geometry_data_t &data);
+RK_API void set_uv1(float2 value, thread geometry_data_t &data);
+
+RK_API float4 custom_attribute(thread geometry_data_t &data);
+RK_API void set_custom_attribute(float4 value, thread geometry_data_t &data);
+}
+
+// MARK: - Uniforms
+
+/// Uniforms are read-only values that are constant for all vertices from the same model.
+/// You can retrieve this object by calling `geometry_parameters.uniforms()`
+struct uniforms
+{
+ RK_INLINE uniforms(thread geometry_data_t &_data)
+ : data(_data)
+ {
+ }
+
+ /// Returns the current simulation time, which you can use to animate other values,
+ /// such as color or position over time.
+ ///
+ /// Time is expressed as seconds since RealityKit began rendering.
+ RK_INLINE float time() const thread
+ {
+ return geometry_modifier::api::time(data);
+ }
+
+ /// Returns a matrix you can use to transform from model-space into world-space.
+ RK_INLINE metal::float4x4 model_to_world() const thread
+ {
+ return geometry_modifier::api::model_to_world(data);
+ }
+
+ /// Returns a matrix you can use to transform from world-space into model-space.
+ RK_INLINE metal::float4x4 world_to_model() const thread
+ {
+ return geometry_modifier::api::world_to_model(data);
+ }
+
+ /// Returns a 3x3 matrix useful for transforming normal vectors from model-space
+ /// into world space.
+ RK_INLINE metal::float3x3 normal_to_world() const thread
+ {
+ return geometry_modifier::api::normal_to_world(data);
+ }
+
+ /// Returns a matrix you can use to transform from model-space into view-space.
+ RK_INLINE metal::float4x4 model_to_view() const thread
+ {
+ return geometry_modifier::api::model_to_view(data);
+ }
+
+ /// Returns a matrix you can use to transform from view-space into projection-space.
+ RK_INLINE metal::float4x4 view_to_projection() const thread
+ {
+ return geometry_modifier::api::view_to_projection(data);
+ }
+
+ /// Returns a matrix you can use to transform from projection-space into view-space.
+ RK_INLINE metal::float4x4 projection_to_view() const thread
+ {
+ return geometry_modifier::api::projection_to_view(data);
+ }
+
+ /// Returns a float4 value, which you set on a model's `CustomMaterial`.
+ ///
+ /// You can use this for any purpose, as its value has no pre-existing meaning within RealityKit.
+ RK_INLINE float4 custom_parameter() const thread
+ {
+ return geometry_modifier::api::custom_parameter(data);
+ }
+
+ /// Returns the value of a model's UV0 offset.
+ ///
+ /// While the built-in PhysicallyBasedMaterial shaders use this to control uv0, Geometry
+ /// Modifiers give you control to use this in any way you see fit.
+ ///
+ /// @see uv0_transform()
+ RK_INLINE float2 uv0_offset() const thread
+ {
+ return geometry_modifier::api::uv0_offset(data);
+ }
+
+ /// Returns the value of a model's UV0 transform.
+ ///
+ /// While the built-in PhysicallyBasedMaterial shaders use this to control uv0, Geometry
+ /// Modifiers give you control to use this in any way you see fit.
+ ///
+ /// If you want to apply this to uv0, you can use code like the following.
+ ///
+ /// @code
+ /// #include <RealityKit/RealityKit.h>
+ ///
+ /// [[visible]]
+ /// void geometryModifier(realitykit::geometry_parameters params)
+ /// {
+ /// params.geometry().set_uv0(params.uniforms().uv0_transform() * params.geometry().uv0() + params.uniforms().uv0_offset());
+ /// }
+ /// @endcode
+ RK_INLINE metal::float2x2 uv0_transform() const thread
+ {
+ return geometry_modifier::api::uv0_transform(data);
+ }
+
+ /// Returns the value of a model's UV1 offset.
+ ///
+ /// While the built-in PhysicallyBasedMaterial shaders use this to control uv1, Geometry
+ /// Modifiers give you control to use this in any way you see fit.
+ ///
+ /// @see uv1_transform()
+ RK_INLINE float2 uv1_offset() const thread
+ {
+ return geometry_modifier::api::uv1_offset(data);
+ }
+
+ /// Returns the value of a model's UV1 transform.
+ ///
+ /// While the built-in PhysicallyBasedMaterial shaders use this to control uv1, Geometry
+ /// Modifiers give you control to use this in any way you see fit.
+ ///
+ /// If you want to apply this to uv1, you can use code like the following.
+ ///
+ /// @code
+ /// #include <RealityKit/RealityKit.h>
+ ///
+ /// [[visible]]
+ /// void geometryModifier(realitykit::geometry_parameters params)
+ /// {
+ /// params.geometry().set_uv1(params.uniforms().uv1_transform() * params.geometry().uv1() + params.uniforms().uv1_offset());
+ /// }
+ /// @endcode
+ RK_INLINE metal::float2x2 uv1_transform() const thread
+ {
+ return geometry_modifier::api::uv1_transform(data);
+ }
+
+private:
+ thread geometry_data_t &data;
+};
+
+// MARK: - Geometry
+
+/// Geometry gives you access to values contained on each vertex within a model,
+/// such as position and color. You can also modify most of the properties, which
+/// you can access later from the surface shader.
+struct geometry
+{
+ RK_INLINE geometry(thread geometry_data_t &_data)
+ : data(_data)
+ {
+ }
+
+ /// Returns per-vertex identifier, as specified by Metal.
+ ///
+ /// See `vertex_id` in Metal Shading Language Section 5.2.3.1.
+ RK_INLINE uint vertex_id() const thread
+ {
+ return geometry_modifier::api::vertex_id(data);
+ }
+
+ /// Position of this vertex in model-space. This will be the value originally
+ /// set when the model was created. You can provide an offset to this value using
+ /// set_model_position_offset().
+ ///
+ /// @see set_model_position_offset()
+ RK_INLINE float3 model_position() const thread
+ {
+ return geometry_modifier::api::position(data);
+ }
+
+ /// Position of this vertex in world-space. This value is computed based on the model_position()
+ /// and the object's position in the virtual world.
+ RK_INLINE float3 world_position() const thread
+ {
+ return (api::model_to_world(data) * float4(model_position(), 1)).xyz;
+ }
+
+ /// Returns any offset for the current vertex, in model-space. Defaults to
+ /// (0,0,0) unless previously set by `set_model_position_offset()`.
+ RK_INLINE float3 model_position_offset() const thread
+ {
+ return geometry_modifier::api::model_position_offset(data);
+ }
+
+ /// Offsets the current vertex by the given value in model-space. The value you provide
+ /// will be added to `model_position()` to determine its final position.
+ RK_INLINE void set_model_position_offset(float3 value) thread
+ {
+ geometry_modifier::api::set_model_position_offset(value, data);
+ }
+
+ /// Returns any offset for the current vertex, by transforming model_position_offset()
+ /// into world-space.
+ RK_INLINE float3 world_position_offset() const thread
+ {
+ return geometry_modifier::api::normal_to_world(data) * model_position_offset();
+ }
+
+ /// Offsets the current vertex by the given value in world-space. The value will be
+ /// transformed into model-space before storing.
+ RK_INLINE void set_world_position_offset(float3 value) thread
+ {
+ float4 model_offset = geometry_modifier::api::world_to_model(data) * float4(value, 0.0);
+
+ set_model_position_offset(model_offset.xyz);
+ }
+
+ /// Returns color for the current vertex. This value is initially any color specified
+ /// on the current vertex, and can be changed with set_color().
+ RK_INLINE float4 color() const thread
+ {
+ return geometry_modifier::api::color(data);
+ }
+
+ /// Sets the current vertex's color.
+ RK_INLINE void set_color(float4 value) thread
+ {
+ geometry_modifier::api::set_color(value, data);
+ }
+
+ /// Returns the normal for the current vertex.
+ RK_INLINE float3 normal() const thread
+ {
+ return geometry_modifier::api::normal(data);
+ }
+
+ /// Sets the current vertex's normal.
+ RK_INLINE void set_normal(float3 value) thread
+ {
+ geometry_modifier::api::set_normal(value, data);
+ }
+
+ /// Returns the bitangent for the current vertex.
+ RK_INLINE float3 bitangent() const thread
+ {
+ return geometry_modifier::api::bitangent(data);
+ }
+
+ /// Sets the current vertex's bitangent.
+ RK_INLINE void set_bitangent(float3 value) thread
+ {
+ geometry_modifier::api::set_bitangent(value, data);
+ }
+
+ /// Returns uv0 for the current vertex. This is the raw value, and may need to be flipped to sample into USD textures.
+ ///
+ /// Most often, you will use this as a primary texture coordinate.
+ RK_INLINE float2 uv0() const thread
+ {
+ return geometry_modifier::api::uv0(data);
+ }
+
+ /// Sets uv0 for the current vertex.
+ RK_INLINE void set_uv0(float2 value) thread
+ {
+ geometry_modifier::api::set_uv0(value, data);
+ }
+
+ /// Returns uv1 for the current vertex. This is the raw value, and may need to be flipped to sample into USD textures.
+ ///
+ /// You can use this as secondary texture coordinate or for any other
+ /// purposes.
+ RK_INLINE float2 uv1() const thread
+ {
+ return geometry_modifier::api::uv1(data);
+ }
+
+ /// Sets uv1 for the current vertex.
+ RK_INLINE void set_uv1(float2 value) thread
+ {
+ geometry_modifier::api::set_uv1(value, data);
+ }
+
+ /// Returns any user-specified attribute on the current vertex.
+ ///
+ /// Defaults to `(0,0,0,0)` unless previously set via set_custom_attribute.
+ RK_INLINE float4 custom_attribute() const thread
+ {
+ return geometry_modifier::api::custom_attribute(data);
+ }
+
+ /// Stores an attribute on the vertex which will later be available in the surface shader.
+ RK_INLINE void set_custom_attribute(float4 value) thread
+ {
+ geometry_modifier::api::set_custom_attribute(value, data);
+ }
+
+private:
+ thread geometry_data_t &data;
+};
+}
+
+// MARK: - Geometry Parameters
+
+/// Parameter passed to geometry modifier functions, providing access to input and
+/// output values.
+///
+/// Geometry modifier functions allow you to modify vertices and their related properties
+/// before rasterization. For example, you can add an offset which simulates the effect of
+/// wind on long grass.
+///
+/// Values are grouped into sub-objects of related values. For example, you can use `textures()`
+/// to access textures bound by your application.
+///
+/// @code
+/// #include <RealityKit/RealityKit.h>
+///
+/// [[visible]]
+/// void myGeometryModifier(realitykit::geometry_parameters params)
+/// {
+/// }
+/// @endcode
+///
+/// Below is a geometry modifier that emulates PhysicallyBasedMaterial's behavior.
+///
+/// @code
+/// #include <RealityKit/RealityKit.h>
+///
+/// [[visible]]
+/// void myGeometryModifier(realitykit::geometry_parameters params)
+/// {
+/// auto geo = params.geometry();
+/// auto uniforms = params.uniforms();
+///
+/// geo.set_uv0(uniforms.uv0_transform() * geo.uv0() + uniforms.uv0_offset());
+/// geo.set_uv1(uniforms.uv1_transform() * geo.uv1() + uniforms.uv1_offset());
+/// }
+/// @endcode
+struct geometry_parameters
+{
+ RK_INLINE geometry_parameters(thread geometry_modifier::geometry_data_t &_data)
+ : data(_data)
+ {
+ }
+
+ RK_INLINE geometry_parameters(const thread geometry_parameters &p) = default;
+
+ /// Returns the uniforms associated with this model.
+ ///
+ /// Uniforms are read-only values that are constant for all vertices and fragments
+ /// from the same model.
+ RK_INLINE geometry_modifier::uniforms uniforms() const thread
+ {
+ return geometry_modifier::uniforms(data);
+ }
+
+ /// Returns the geometry associated with the current vertex, allowing you to access
+ /// and customize aspects of the model, such as the color or uvs, or to add offsets
+ /// to the position.
+ RK_INLINE geometry_modifier::geometry geometry() thread
+ {
+ return geometry_modifier::geometry(data);
+ }
+
+ /// Returns the textures associated with this model, allowing you to retrieve
+ /// and sample textures set on the model.
+ RK_INLINE texture::textures textures() const thread
+ {
+ return texture::textures(geometry_modifier::api::textures(data));
+ }
+
+ /// Returns the material constants associated with this model. These values
+ /// are constant across a given model, and allow access to parameters set on
+ /// the `CustomMaterial`, such as `base_color_tint` or `roughness`.
+ RK_INLINE material::material_parameters material_constants() const thread
+ {
+ return material::material_parameters(geometry_modifier::api::material_constants(data));
+ }
+
+private:
+ thread geometry_modifier::geometry_data_t &data;
+};
+}
+
+#endif // __METAL_VERSION__
+#endif // REALITYKIT_GEOMETRYMODIFIER_H_
diff -ruN /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitMaterialParameters.h /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitMaterialParameters.h
--- /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitMaterialParameters.h 1969-12-31 19:00:00.000000000 -0500
+++ /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitMaterialParameters.h 2021-06-02 00:24:17.000000000 -0400
@@ -0,0 +1,117 @@
+#ifndef REALITYKIT_MATERIAL_PARAMETERS_H
+#define REALITYKIT_MATERIAL_PARAMETERS_H
+
+//
+// Copyright © 2021 Apple Inc. All rights reserved.
+//
+#if defined(__METAL_VERSION__)
+
+#ifndef __REALITYKIT_INDIRECT
+#error "Please include <RealityKit/RealityKit.h> instead of individual files directly"
+#endif
+
+#include <RealityKit/RealityKitTypes.h>
+
+namespace realitykit
+{
+struct surface_parameters;
+struct geometry_parameters;
+
+namespace material
+{
+struct material_constants_t;
+
+namespace api
+{
+// Material Constants
+
+RK_API float3 base_color_tint(thread material_constants_t &data);
+RK_API float opacity_scale(thread material_constants_t &data);
+RK_API float opacity_threshold(thread material_constants_t &data);
+RK_API float roughness_scale(thread material_constants_t &data);
+RK_API float metallic_scale(thread material_constants_t &data);
+RK_API float specular_scale(thread material_constants_t &data);
+RK_API float3 emissive_color(thread material_constants_t &data);
+RK_API float clearcoat_scale(thread material_constants_t &data);
+RK_API float clearcoat_roughness_scale(thread material_constants_t &data);
+} // namespace api
+
+// MARK: - Material Parameters
+
+/// Material parameters that are constant across one instance of a model. These values
+/// are set on the `Material` and available for use in your calculations.
+///
+/// When providing a surface shader, you are responsible for using these values
+/// as desired for your final look.
+struct material_parameters
+{
+ RK_INLINE material_parameters(thread material::material_constants_t &_data)
+ : data(_data)
+ {
+ }
+
+ /// Returns the value of baseColor.tint set on the model's material.
+ RK_INLINE float3 base_color_tint() const thread
+ {
+ return material::api::base_color_tint(data);
+ }
+
+ /// Returns the value of baseColor.tint.alpha set on the model's material.
+ RK_INLINE float opacity_scale() const thread
+ {
+ return material::api::opacity_scale(data);
+ }
+
+ /// Returns the value of opacityThreshold set on the model's material.
+ ///
+ /// Defaults to 0.
+ RK_INLINE float opacity_threshold() const thread
+ {
+ return material::api::opacity_threshold(data);
+ }
+
+ /// Returns the value of roughness.scale set on the model's material.
+ RK_INLINE float roughness_scale() const thread
+ {
+ return material::api::roughness_scale(data);
+ }
+
+ /// Returns the value of metallic.scale set on the model's material.
+ RK_INLINE float metallic_scale() const thread
+ {
+ return material::api::metallic_scale(data);
+ }
+
+ /// Returns the value of specular.scale set on the model's material.
+ RK_INLINE float specular_scale() const thread
+ {
+ return material::api::specular_scale(data);
+ }
+
+ /// Returns the value of emissiveColor set on the model's material.
+ RK_INLINE float3 emissive_color() const thread
+ {
+ return material::api::emissive_color(data);
+ }
+
+ /// Returns the value of clearcoat.scale set on the model's material.
+ RK_INLINE float clearcoat_scale() const thread
+ {
+ return material::api::clearcoat_scale(data);
+ }
+
+ /// Returns the value of clearcoatRoughness.scale set on the model's material.
+ RK_INLINE float clearcoat_roughness_scale() const thread
+ {
+ return material::api::clearcoat_roughness_scale(data);
+ }
+
+private:
+ thread material::material_constants_t &data;
+};
+
+} // namespace material
+} // namespace realitykit
+
+#endif // __METAL_VERSION__
+#endif /* REALITYKIT_MATERIAL_PARAMETERS_H */
diff -ruN /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitSurfaceShader.h /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitSurfaceShader.h
--- /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitSurfaceShader.h 1969-12-31 19:00:00.000000000 -0500
+++ /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitSurfaceShader.h 2021-06-01 21:51:40.000000000 -0400
@@ -0,0 +1,550 @@
+#ifndef REALITYKIT_SURFACESHADER_H_
+#define REALITYKIT_SURFACESHADER_H_
+
+//
+// Copyright © 2021 Apple Inc. All rights reserved.
+//
+#if defined(__METAL_VERSION__)
+
+#ifndef __REALITYKIT_INDIRECT
+#error "Please include <RealityKit/RealityKit.h> instead of individual files directly"
+#endif
+
+#include <RealityKit/RealityKitMaterialParameters.h>
+#include <RealityKit/RealityKitTextures.h>
+#include <RealityKit/RealityKitTypes.h>
+
+#include <metal_stdlib>
+#include <metal_types>
+
+namespace realitykit
+{
+struct surface_parameters;
+
+namespace surface
+{
+struct surface_data_t;
+
+namespace api
+{
+// Uniforms
+
+RK_API float time(thread surface_data_t &data);
+
+RK_API thread texture::texture_data_t &textures(thread surface_data_t &data);
+RK_API thread material::material_constants_t &material_constants(thread surface_data_t &data);
+RK_API float4 custom_parameter(thread surface_data_t &data);
+
+// Transforms
+RK_API metal::float4x4 model_to_world(thread surface_data_t &data);
+RK_API metal::float4x4 model_to_view(thread surface_data_t &data);
+
+RK_API metal::float4x4 world_to_view(thread surface_data_t &data);
+
+RK_API metal::float4x4 view_to_projection(thread surface_data_t &data);
+RK_API metal::float4x4 projection_to_view(thread surface_data_t &data);
+
+// Geometry
+
+RK_API float3 model_position(thread surface_data_t &data);
+RK_API float4 screen_position(thread surface_data_t &data);
+RK_API float3 world_position(thread surface_data_t &data);
+RK_API float3 view_direction(thread surface_data_t &data);
+
+RK_API float4 color(thread surface_data_t &data);
+
+RK_API float3 geometry_normal(thread surface_data_t &data);
+RK_API float3 geometry_tangent(thread surface_data_t &data);
+RK_API float3 geometry_bitangent(thread surface_data_t &data);
+
+RK_API float2 uv0(thread surface_data_t &data);
+RK_API float2 uv1(thread surface_data_t &data);
+
+RK_API float4 custom_attribute(thread surface_data_t &data);
+
+// Surface
+
+RK_API half3 base_color(thread surface_data_t &data);
+RK_API void set_base_color(half3 value, thread surface_data_t &data);
+
+RK_API float3 tangent_space_normal(thread surface_data_t &data);
+RK_API void set_tangent_space_normal(float3 value, thread surface_data_t &data);
+
+RK_API half3 emissive_color(thread surface_data_t &data);
+RK_API void set_emissive_color(half3 value, thread surface_data_t &data);
+
+RK_API half roughness(thread surface_data_t &data);
+RK_API void set_roughness(half value, thread surface_data_t &data);
+
+RK_API half metallic(thread surface_data_t &data);
+RK_API void set_metallic(half value, thread surface_data_t &data);
+
+RK_API half ambient_occlusion(thread surface_data_t &data);
+RK_API void set_ambient_occlusion(half value, thread surface_data_t &data);
+
+RK_API half specular(thread surface_data_t &data);
+RK_API void set_specular(half value, thread surface_data_t &data);
+
+RK_API half opacity(thread surface_data_t &data);
+RK_API void set_opacity(half value, thread surface_data_t &data);
+
+RK_API half clearcoat(thread surface_data_t &data);
+RK_API void set_clearcoat(half value, thread surface_data_t &data);
+
+RK_API half clearcoat_roughness(thread surface_data_t &data);
+RK_API void set_clearcoat_roughness(half value, thread surface_data_t &data);
+
+} // namespace api
+
+// MARK: - Uniforms
+
+/// Uniforms are read-only values that are constant for all vertices and fragments
+/// from the same model.
+struct uniforms
+{
+ RK_INLINE uniforms(thread surface::surface_data_t &_data)
+ : data(_data)
+ {
+ }
+
+ /// Returns the current simulation time, which you can use to animate other values,
+ /// such as color or position over time.
+ ///
+ /// Time is expressed as seconds since RealityKit began rendering.
+ RK_INLINE float time() const thread
+ {
+ return surface::api::time(data);
+ }
+
+ /// Returns a matrix you can use to transform from model-space into world-space.
+ RK_INLINE metal::float4x4 model_to_world() const thread
+ {
+ return surface::api::model_to_world(data);
+ }
+
+ /// Returns a matrix you can use to transform from model-space into view-space.
+ RK_INLINE metal::float4x4 model_to_view() const thread
+ {
+ return surface::api::model_to_view(data);
+ }
+
+ /// Returns a matrix you can use to transform from world-space into view-space.
+ RK_INLINE metal::float4x4 world_to_view() const thread
+ {
+ return surface::api::world_to_view(data);
+ }
+
+ /// Returns a matrix you can use to transform from view-space into projection-space.
+ RK_INLINE metal::float4x4 view_to_projection() const thread
+ {
+ return surface::api::view_to_projection(data);
+ }
+
+ /// Returns a matrix you can use to transform from projection-space into view-space.
+ RK_INLINE metal::float4x4 projection_to_view() const thread
+ {
+ return surface::api::projection_to_view(data);
+ }
+
+ /// Returns a float4 value, which you set on a model's `CustomMaterial`.
+ ///
+ /// You can use this for any purpose, as its value has no pre-existing meaning within RealityKit.
+ RK_INLINE float4 custom_parameter() const thread
+ {
+ return surface::api::custom_parameter(data);
+ }
+
+private:
+ thread surface::surface_data_t &data;
+};
+
+// MARK: - Geometry
+
+/// Geometry properties for a surface shader.
+///
+/// The geometry object provides access to data about a fragment's input geometry,
+/// such as its screen position, normal, and uv's. This data is read-only at the fragment
+/// stage. See surface_properties for modifyable values, including tangent-space normal.
+struct geometry
+{
+ RK_INLINE geometry(thread surface::surface_data_t &_data)
+ : data(_data)
+ {
+ }
+
+ /// Returns the fragment's position in screen space.
+ ///
+ /// Corresponds to the `[[position]]` fragment function input attribute
+ RK_INLINE float4 screen_position() const thread
+ {
+ return surface::api::screen_position(data);
+ }
+
+ /// Returns the fragment's position in world space
+ RK_INLINE float3 world_position() const thread
+ {
+ return surface::api::world_position(data);
+ }
+
+ /// Returns the fragment's position in model space
+ RK_INLINE float3 model_position() const thread
+ {
+ return surface::api::model_position(data);
+ }
+
+ /// Returns the fragment's interpolated vertex color.
+ RK_INLINE float4 color() const thread
+ {
+ return surface::api::color(data);
+ }
+
+ /// Returns the normal of the fragment's geometry.
+ RK_INLINE float3 normal() const thread
+ {
+ return surface::api::geometry_normal(data);
+ }
+
+ /// Returns the tangent of the fragment's geometry.
+ RK_INLINE float3 tangent() const thread
+ {
+ return surface::api::geometry_tangent(data);
+ }
+
+ /// Returns the bitangent of the fragment's geometry.
+ RK_INLINE float3 bitangent() const thread
+ {
+ return surface::api::geometry_bitangent(data);
+ }
+
+ /// Returns the interpolated uv0 for the current fragment. This is the raw value, and may need to be flipped to sample into USD textures.
+ ///
+ /// Most often, you will use this as a primary texture coordinate.
+ RK_INLINE float2 uv0() const thread
+ {
+ return surface::api::uv0(data);
+ }
+
+ /// Returns the interpolated uv1 for the current fragment. This is the raw value, and may need to be flipped to sample into USD textures.
+ ///
+ /// You can use this as secondary texture coordinate or for any other purpose.
+ RK_INLINE float2 uv1() const thread
+ {
+ return surface::api::uv1(data);
+ }
+
+ /// Returns a user attribute set by a geometry modifier.
+ ///
+ /// You set this value in a geometry modifier and the value is interpolated per-fragment,
+ /// using Metal's default interpolation mode.
+ RK_INLINE float4 custom_attribute() const thread
+ {
+ return surface::api::custom_attribute(data);
+ }
+
+ /// Returns the direction from this fragment to the view, in world-space.
+ RK_INLINE float3 view_direction() const thread
+ {
+ return surface::api::view_direction(data);
+ }
+
+private:
+ thread surface::surface_data_t &data;
+};
+
+// MARK: - Surface Properties
+
+/// Surface properties for a surface shader.
+///
+/// The surface sub-object allows you to define the surface's properties at this fragment,
+/// including color, normal, roughness, etc.
+///
+/// @code
+/// #include <RealityKit/RealityKit.h>
+///
+/// [[visible]]
+/// void mySurfaceShader(realitykit::surface_parameters params)
+/// {
+/// params.surface().set_base_color(half3(1, 1, 1));
+/// }
+/// @endcode
+///
+/// Below is a surface shader for the lit lighting model that emulates
+/// PhysicallyBasedMaterial's behavior.
+///
+/// @code
+/// #include <RealityKit/RealityKit.h>
+///
+/// [[visible]]
+/// void mySurfaceShader(realitykit::surface_parameters params)
+/// {
+/// constexpr sampler samplerBilinear(coord::normalized,
+/// address::repeat,
+/// filter::linear,
+/// mip_filter::nearest);
+///
+/// auto tex = params.textures();
+/// auto surface = params.surface();
+/// float2 uv = params.geometry().uv0();
+/// // USD textures require uvs to be flipped.
+/// uv.y = 1.0 - uv.y;
+///
+/// half4 colorSample = tex.base_color().sample(samplerBilinear, uv);
+/// half4 emissiveSample = tex.emissive_color().sample(samplerBilinear, uv);
+///
+/// // Color
+/// surface.set_base_color(colorSample.rgb * half3(params.material_constants().base_color_tint()));
+/// surface.set_emissive_color(max(emissiveSample.rgb, half3(params.material_constants().emissive_color())));
+///
+/// // Opacity
+/// surface.set_opacity(tex.opacity().sample(samplerBilinear, uv).r
+/// * params.material_constants().opacity_scale()
+/// * colorSample.a);
+///
+/// // Normal
+/// half3 normal = realitykit::unpack_normal(tex.normal().sample(samplerBilinear, uv).rgb);
+/// surface.set_normal(float3(normal));
+///
+/// // Roughness and Metallic
+/// surface.set_roughness(tex.roughness().sample(samplerBilinear, uv).r
+/// * params.material_constants().roughness_scale());
+/// surface.set_metallic(tex.metallic().sample(samplerBilinear, uv).r
+/// * params.material_constants().metallic_scale());
+///
+/// // Ambient and Specular
+/// surface.set_ambient_occlusion(tex.ambient_occlusion().sample(samplerBilinear, uv).r);
+/// surface.set_specular(tex.specular().sample(samplerBilinear, uv).r
+/// * params.material_constants().specular_scale());
+/// }
+/// @endcode
+struct surface_properties
+{
+ RK_INLINE surface_properties(thread surface::surface_data_t &_data)
+ : data(_data)
+ {
+ }
+
+ /// Returns the base color for the fragment. The default value is (1,1,1)
+ ///
+ /// For materials using the unlit lighting model, use set_emissive_color() instead.
+ RK_INLINE half3 base_color() const thread
+ {
+ return surface::api::base_color(data);
+ }
+
+ /// Set the base color of this fragment. The default value is (1,1,1)
+ ///
+ /// For materials with the unlit lighting model, use set_emissive_color instead.
+ RK_INLINE void set_base_color(half3 value) thread
+ {
+ surface::api::set_base_color(value, data);
+ }
+
+ /// Returns the tangent-space normal of the current fragment.
+ ///
+ /// Defaults to (0,0,1).
+ RK_INLINE float3 normal() thread
+ {
+ return surface::api::tangent_space_normal(data);
+ }
+
+ /// Sets the tangent-space normal of the current fragment.
+ ///
+ /// You can set this value to influence lighting calculations. The value will
+ /// be normalized before storing.
+ RK_INLINE void set_normal(float3 value) thread
+ {
+ return surface::api::set_tangent_space_normal(metal::normalize(value), data);
+ }
+
+ /// Returns the emissive color for the fragment's material. The default value is (0,0,0)
+ RK_INLINE half3 emissive_color() const thread
+ {
+ return surface::api::emissive_color(data);
+ }
+
+ /// Set the emissive color of this fragment.
+ ///
+ /// Use this to add light emitted for glowing materials, or as the output color when
+ /// using the unlit lighting model.
+ RK_INLINE void set_emissive_color(half3 value) thread
+ {
+ surface::api::set_emissive_color(value, data);
+ }
+
+ /// Returns the roughness of the fragment's material. The default value is 0.
+ RK_INLINE half roughness() const thread
+ {
+ return surface::api::roughness(data);
+ }
+
+ /// Set the roughness value of this fragment.
+ RK_INLINE void set_roughness(half value) thread
+ {
+ surface::api::set_roughness(value, data);
+ }
+
+ /// Returns the metallic of the fragment's material. The default value is 0.
+ RK_INLINE half metallic() const thread
+ {
+ return surface::api::metallic(data);
+ }
+
+ /// Set the metallic value of this fragment.
+ RK_INLINE void set_metallic(half value) thread
+ {
+ surface::api::set_metallic(value, data);
+ }
+
+ /// Returns the ambient occlusion value of the fragment's material. The default value is 1.
+ RK_INLINE half ambient_occlusion() const thread
+ {
+ return surface::api::ambient_occlusion(data);
+ }
+
+ /// Set the ambient occlusion value of this fragment.
+ RK_INLINE void set_ambient_occlusion(half value) thread
+ {
+ surface::api::set_ambient_occlusion(value, data);
+ }
+
+ /// Returns the specular value of this fragment. The default value is 0.
+ RK_INLINE half specular() const thread
+ {
+ return surface::api::specular(data);
+ }
+
+ /// Set the specular value of this fragment.
+ RK_INLINE void set_specular(half value) thread
+ {
+ surface::api::set_specular(value, data);
+ }
+
+ /// Returns any previously set opacity for this fragment. The default value is 1.
+ RK_INLINE half opacity() const thread
+ {
+ return surface::api::opacity(data);
+ }
+
+ /// Set the opacity of this fragment. When the material has a transparent
+ /// blending mode, this specifies how opaque the fragment is.
+ ///
+ /// @see CustomMaterial.blending
+ RK_INLINE void set_opacity(half value) thread
+ {
+ surface::api::set_opacity(value, data);
+ }
+
+ /// Returns any previously set clearcoat value for this fragment. The default value is 0.
+ RK_INLINE half clearcoat() const thread
+ {
+ return surface::api::clearcoat(data);
+ }
+
+ /// Set the clearcoat value for this fragment.
+ ///
+ /// @discussion This requires that the CustomMaterial's lighting model is clearcoat, otherwise
+ /// its value will be ignored.
+ RK_INLINE void set_clearcoat(half value) thread
+ {
+ surface::api::set_clearcoat(value, data);
+ }
+
+ /// Returns any previously set clearcoat roughness value for this fragment. The default value is 0.
+ RK_INLINE half clearcoat_roughness() const thread
+ {
+ return surface::api::clearcoat_roughness(data);
+ }
+
+ /// Set the clearcoat roughness value for this fragment.
+ ///
+ /// @discussion This requires that the CustomMaterial's lighting model is clearcoat, otherwise
+ /// its value will be ignored.
+ RK_INLINE void set_clearcoat_roughness(half value) thread
+ {
+ surface::api::set_clearcoat_roughness(value, data);
+ }
+
+private:
+ thread surface::surface_data_t &data;
+};
+}
+
+// MARK: - Surface Parameters
+
+/// Parameter passed to surface shader functions, which you use to define the surface's properties
+/// at this fragment. You control the full appearance of the surface; any values not set by your surface
+/// shader use default values.
+///
+/// Values are grouped into sub-objects of related values. For example, you can use `textures()`
+/// to access textures bound by your application and `surface()` to define the surface appearance.
+///
+/// Example shader which pulses its color over time, on a relatively rough surface.
+///
+/// @code
+/// #include <RealityKit/RealityKit.h>
+///
+/// [[visible]]
+/// void pulsingSurfaceShader(realitykit::surface_parameters params)
+/// {
+/// float intensity = sin(params.uniforms().time());
+/// params.surface().set_base_color(half3(intensity));
+/// params.surface().set_roughness(0.75);
+/// }
+/// @endcode
+struct surface_parameters
+{
+ RK_INLINE surface_parameters(thread surface::surface_data_t &_data)
+ : data(_data)
+ {
+ }
+
+ RK_INLINE surface_parameters(const thread surface_parameters &p) = default;
+
+ /// Returns the uniforms associated with this fragments.
+ ///
+ /// Uniforms are read-only values that are constant across all vertices and fragments
+ /// from the same model.
+ RK_INLINE surface::uniforms uniforms() const thread
+ {
+ return surface::uniforms(data);
+ }
+
+ /// Returns the geometric properties of the current fragment
+ ///
+ /// Geometry is read-only at the fragment stage. See surface() for modifyable values,
+ /// including tangent-space normal.
+ RK_INLINE surface::geometry geometry() const thread
+ {
+ return surface::geometry(data);
+ }
+
+ /// Returns an object you use to define the surface's properties for this fragment.
+ ///
+ /// All properties are initialized to default values.
+ RK_INLINE surface::surface_properties surface() thread
+ {
+ return surface::surface_properties(data);
+ }
+
+ /// Returns the textures associated with this model, allowing you to retrieve
+ /// and sample textures set on the model.
+ RK_INLINE texture::textures textures() const thread
+ {
+ return texture::textures(surface::api::textures(data));
+ }
+
+ /// Returns the material constants associated with this model. These values
+ /// are constant across a given model, allowing you to access parameters set on
+ /// the CustomMaterial, such as base_color_tint or roughness.
+ RK_INLINE material::material_parameters material_constants() const thread
+ {
+ return material::material_parameters(surface::api::material_constants(data));
+ }
+
+private:
+ thread surface::surface_data_t &data;
+};
+} // namespace realitykit
+
+#endif // __METAL_VERSION__
+#endif // REALITYKIT_SURFACESHADER_H_
diff -ruN /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitTextures.h /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitTextures.h
--- /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitTextures.h 1969-12-31 19:00:00.000000000 -0500
+++ /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitTextures.h 2021-06-02 00:24:17.000000000 -0400
@@ -0,0 +1,223 @@
+#ifndef REALITYKIT_TEXTURES_H
+#define REALITYKIT_TEXTURES_H
+
+//
+// Copyright © 2021 Apple Inc. All rights reserved.
+//
+#if defined(__METAL_VERSION__)
+
+#ifndef __REALITYKIT_INDIRECT
+#error "Please include <RealityKit/RealityKit.h> instead of individual files directly"
+#endif
+
+#include <RealityKit/RealityKitTypes.h>
+
+#include <metal_common>
+#include <metal_geometric>
+#include <metal_texture>
+
+namespace realitykit
+{
+struct surface_parameters;
+struct geometry_parameters;
+
+/// Unpack a tangent-space normal from a two-component texture representation.
+///
+/// @discussion The Z component will be computed from the xy components, and the result
+/// will be normalized.
+///
+/// Call this overload if your texture encodes only the x/y components of the normal,
+/// or your data may not already be normalized. If you don't need re-normalization, call
+/// unpack_normal with three components
+///
+/// @see unpack_normal(half3)
+RK_INLINE half3 unpack_normal(half2 packed_normal)
+{
+ using namespace metal;
+
+ half3 normal;
+ normal.xy = (packed_normal.xy * 2.0h - 1.0h);
+ normal.z = sqrt(1.0h - saturate(dot(normal.xy,normal.xy)));
+ return normal;
+}
+
+/// Unpack a tangent-space normal from a three-component packed texture representation.
+///
+/// @discussion This overload maps a packed normal in the range (0, 1) into (-1, 1). The resulting
+/// normal will not be normalized. To re-normalize the value, call unpack_normal with the xy components.
+///
+/// @see unpack_normal(half2)
+///
+/// @param packed_normal A packed normal where each component is in the range (0, 1).
+///
+RK_INLINE half3 unpack_normal(half3 packed_normal)
+{
+ return packed_normal * 2.0h - 1.0h;
+}
+
+/// Unpack a tangent-space normal from a three component texture representation, and increases
+/// or decreases its intensity.
+///
+/// @discussion The intensity of the normal will be modulated by scaling the x/y components by intensity.
+/// The Z component will then be computed from the xy components, resulting in a normalized value.
+///
+/// @param intensity Values greater than one will increase the intensity, where values smaller
+/// than 1 will reduce the intensity.
+RK_INLINE half3 unpack_normal(half3 packed_normal, half intensity)
+{
+ using namespace metal;
+
+ half3 normal;
+ normal.xy = (packed_normal.xy * 2.0h - 1.0h) * intensity;
+ normal.z = sqrt(1.0h - saturate(dot(normal.xy,normal.xy)));
+ return normal;
+}
+
+namespace texture
+{
+struct texture_data_t;
+
+namespace api
+{
+RK_API metal::texture2d<half> base_color(thread texture_data_t &data);
+RK_API metal::texture2d<half> opacity(thread texture_data_t &data);
+RK_API metal::texture2d<half> normal(thread texture_data_t &data);
+RK_API metal::texture2d<half> emissive_color(thread texture_data_t &data);
+RK_API metal::texture2d<half> roughness(thread texture_data_t &data);
+RK_API metal::texture2d<half> metallic(thread texture_data_t &data);
+RK_API metal::texture2d<half> ambient_occlusion(thread texture_data_t &data);
+RK_API metal::texture2d<half> specular(thread texture_data_t &data);
+RK_API metal::texture2d<half> clearcoat(thread texture_data_t &data);
+RK_API metal::texture2d<half> clearcoat_roughness(thread texture_data_t &data);
+RK_API metal::texture2d<half> custom(thread texture_data_t &data);
+} // namespace api
+
+// MARK: - Textures
+
+/// Provides access to textures that are applied to a model.
+///
+/// @discussion When textures are loaded from a USD, their origin will be in the bottom
+/// left corner, rather than the top left which Metal samples in. To account for this,
+/// flip your UVs vertically before sampling.
+///
+/// @code
+/// constexpr sampler samplerBilinear(coord::normalized,
+/// address::repeat,
+/// filter::linear,
+/// mip_filter::nearest);
+///
+/// float2 uv = params.geometry().uv0();
+///
+/// // Flip uvs vertically.
+/// uv.y = 1.0 - uv.y;
+///
+/// float4 color = params.textures().base_color().sample(samplerBilinear, uv);
+/// @endcode
+///
+/// This is available in both geometry modifier and surface shader functions.
+struct textures
+{
+ RK_INLINE textures(thread texture::texture_data_t &_data)
+ : data(_data)
+ {
+ }
+
+ /// Returns any base color texture assigned to the model.
+ ///
+ /// If no texture is assigned, returns a texture containing (1,1,1,1).
+ RK_INLINE metal::texture2d<half> base_color() const thread
+ {
+ return texture::api::base_color(data);
+ }
+
+ /// Returns any opacity texture assigned to the model.
+ ///
+ /// If no texture is assigned, returns a texture containing (1,1,1,1).
+ RK_INLINE metal::texture2d<half> opacity() const thread
+ {
+ return texture::api::opacity(data);
+ }
+
+ /// Returns any normal map texture assigned to the model
+ ///
+ /// If no texture is assigned, returns a texture containing a light blue color,
+ /// representing a default normal.
+ RK_INLINE metal::texture2d<half> normal() const thread
+ {
+ return texture::api::normal(data);
+ }
+
+ /// Returns any emissive color texture assigned to the model
+ ///
+ /// If no texture is assigned, returns a texture containing (0,0,0,1).
+ RK_INLINE metal::texture2d<half> emissive_color() const thread
+ {
+ return texture::api::emissive_color(data);
+ }
+
+ /// Returns any roughness texture assigned to the model
+ ///
+ /// If no texture is assigned, returns a texture containing (1,1,1,1).
+ RK_INLINE metal::texture2d<half> roughness() const thread
+ {
+ return texture::api::roughness(data);
+ }
+
+ /// Returns any metallic texture assigned to the model
+ ///
+ /// If no texture is assigned, returns a texture containing (1,1,1,1).
+ RK_INLINE metal::texture2d<half> metallic() const thread
+ {
+ return texture::api::metallic(data);
+ }
+
+ /// Returns any ambient occlusion texture assigned to the model
+ ///
+ /// If no texture is assigned, returns a texture containing (1,1,1,1).
+ RK_INLINE metal::texture2d<half> ambient_occlusion() const thread
+ {
+ return texture::api::ambient_occlusion(data);
+ }
+
+ /// Returns any specular texture assigned to the model
+ ///
+ /// If no texture is assigned, returns a texture containing (1,1,1,1).
+ RK_INLINE metal::texture2d<half> specular() const thread
+ {
+ return texture::api::specular(data);
+ }
+
+ /// Returns any clearcoat texture assigned to the model.
+ ///
+ /// If no texture is assigned, returns a texture containing (1,1,1,1).
+ RK_INLINE metal::texture2d<half> clearcoat() const thread
+ {
+ return texture::api::clearcoat(data);
+ }
+
+ /// Returns any clearcoat roughness texture assigned to the model.
+ ///
+ /// If no texture is assigned, returns a texture containing (1,1,1,1).
+ RK_INLINE metal::texture2d<half> clearcoat_roughness() const thread
+ {
+ return texture::api::clearcoat_roughness(data);
+ }
+
+ /// Returns a custom texture you have previously set on the CustomMaterial. You can use
+ /// it to store and access any texture data you'd like. It is not otherwise used within RealityKit.
+ ///
+ /// If no texture is assigned, returns a texture containing (0,0,0,1).
+ RK_INLINE metal::texture2d<half> custom() const thread
+ {
+ return texture::api::custom(data);
+ }
+
+private:
+ thread texture::texture_data_t &data;
+};
+
+} // namespace texture
+} // namespace realitykit
+
+#endif // __METAL_VERSION__
+#endif /* REALITYKIT_TEXTURES_H */
diff -ruN /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitTypes.h /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitTypes.h
--- /Applications/Xcode_12.5.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitTypes.h 1969-12-31 19:00:00.000000000 -0500
+++ /Applications/Xcode_13.0.0-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/RealityKit.framework/Headers/RealityKitTypes.h 2021-06-02 00:24:17.000000000 -0400
@@ -0,0 +1,62 @@
+#ifndef REALITYKIT_TYPES_H_
+#define REALITYKIT_TYPES_H_
+
+//
+// Copyright © 2021 Apple Inc. All rights reserved.
+//
+#if defined(__METAL_VERSION__)
+
+#include <RealityKit/RealityKitConfig.h>
+
+#include <metal_config>
+
+#if __METAL_VERSION__ < 230
+#warning "Metal version 2.3 is required for surface shaders"
+#endif
+
+#if RK_BUILD_TIME_LINKING
+
+// Temporary flags during experimentation or development on older OS'es. In this
+// mode, the shader is linked at compile-time.
+#define RK_API extern
+#define RK_INLINE inline __attribute__((__always_inline__))
+
+#else
+
+#if __HAVE_VISIBLE_FUNCTIONS__
+#define RK_API [[visible]]
+#else
+#define RK_API
+#endif
+
+#define RK_INLINE inline __attribute__((__always_inline__))
+
+#endif
+
+namespace realitykit
+{
+
+namespace geometry_modifier
+{
+struct geometry_data_t;
+}
+
+namespace texture
+{
+struct texture_data_t;
+}
+
+namespace material
+{
+struct material_constants_t;
+}
+
+namespace surface
+{
+struct surface_data_t;
+}
+
+} // namespace realitykit
+
+#endif // __METAL_VERSION__
+#endif // REALITYKIT_TYPES_H_
- README
- xcode13.0 Binding Status
- xcode13.1 Binding Status
- xcode13.2 Binding Status
- xcode13.3 Binding Status
- xcode13.4 Binding Status
- xcode14.0 Binding Status
- xcode14.1 Binding Status
- xcode14.2 Binding Status
- xcode14.3 Binding Status
- xcode15.0 Binding Status
- xcode15.1 Binding Status
- xcode15.3 Binding Status
- xcode15.4 Binding Status