objc2_scene_kit/generated/

SCNScene.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-app-kit")]
#[cfg(target_os = "macos")]
use objc2_app_kit::*;
#[cfg(feature = "objc2-core-foundation")]
use objc2_core_foundation::*;
use objc2_foundation::*;

use crate::*;

/// Signature of a block that will be called repeatedly while the scene is being exported.
///
/// Parameter `totalProgress`: is a floating-point number between 0 and 1. 0 means the loading process has just started and 1 that it is complete.
///
/// Parameter `error`: Will contain information about the failure if any.
///
/// Parameter `stop`: Set *stop to YES if you want to abort the operation.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnsceneexportprogresshandler?language=objc)
#[cfg(feature = "block2")]
pub type SCNSceneExportProgressHandler =
    *mut block2::DynBlock<dyn Fn(c_float, *mut NSError, NonNull<Bool>)>;

extern "C" {
    /// Specifies the final destination (as a NSURL) of the scene being exported.
    ///
    /// The destination URL is required if the scene is exported to a temporary directory and then moved to a final destination. This enables the exported document to get correct relative paths to referenced images.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnsceneexportdestinationurl?language=objc)
    pub static SCNSceneExportDestinationURL: &'static NSString;
}

/// Scene attributes
///
/// These keys can be used with the -[SCNScene attributeForKey:] method.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnsceneattribute?language=objc)
// NS_TYPED_ENUM
pub type SCNSceneAttribute = NSString;

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnscenestarttimeattributekey?language=objc)
    pub static SCNSceneStartTimeAttributeKey: &'static SCNSceneAttribute;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnsceneendtimeattributekey?language=objc)
    pub static SCNSceneEndTimeAttributeKey: &'static SCNSceneAttribute;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnsceneframerateattributekey?language=objc)
    pub static SCNSceneFrameRateAttributeKey: &'static SCNSceneAttribute;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnsceneupaxisattributekey?language=objc)
    pub static SCNSceneUpAxisAttributeKey: &'static SCNSceneAttribute;
}

extern_class!(
    /// SCNScene is the class that describes a 3d scene. It encapsulates a node hierarchy.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnscene?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SCNScene;
);

extern_conformance!(
    unsafe impl NSCoding for SCNScene {}
);

extern_conformance!(
    unsafe impl NSObjectProtocol for SCNScene {}
);

extern_conformance!(
    unsafe impl NSSecureCoding for SCNScene {}
);

impl SCNScene {
    extern_methods!(
        #[unsafe(method(scene))]
        #[unsafe(method_family = none)]
        pub unsafe fn scene() -> Retained<Self>;

        #[cfg(feature = "SCNNode")]
        /// Specifies the root node of the node hierarchy.
        ///
        /// Note that we have only one root node, whereas some file formats might have many nodes
        /// at the root of their hierarchies. The root node(s) of the imported files will therefore be children
        /// of the SCNScene's root node.
        #[unsafe(method(rootNode))]
        #[unsafe(method_family = none)]
        pub unsafe fn rootNode(&self) -> Retained<SCNNode>;

        #[cfg(feature = "SCNPhysicsWorld")]
        /// Specifies the physics world of the receiver.
        ///
        /// Every scene automatically creates a physics world object to simulate physics on nodes in the scene. You use this property to access the scene’s global physics properties, such as gravity. To add physics to a particular node, see physicsBody.
        #[unsafe(method(physicsWorld))]
        #[unsafe(method_family = none)]
        pub unsafe fn physicsWorld(&self) -> Retained<SCNPhysicsWorld>;

        /// Retrieves a scene attribute.
        ///
        /// The available keys are listed in the "Scene attributes" group.
        ///
        /// Parameter `key`: An NSString object that specifies the attribute to be read
        #[unsafe(method(attributeForKey:))]
        #[unsafe(method_family = none)]
        pub unsafe fn attributeForKey(&self, key: &NSString) -> Option<Retained<AnyObject>>;

        /// Sets a scene attribute
        ///
        /// The available keys are listed in the "Scene attributes" group.
        ///
        /// Parameter `attribute`: An object that specifies the value of the attribute to be written.
        ///
        /// Parameter `key`: An NSString object that specifies the attribute to be written
        #[unsafe(method(setAttribute:forKey:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAttribute_forKey(&self, attribute: Option<&AnyObject>, key: &NSString);

        #[cfg(feature = "SCNMaterialProperty")]
        /// Specifies the background of the receiver.
        ///
        /// The background is rendered before the rest of the scene.
        /// The background can be rendered as a skybox by setting a cube map as described in SCNMaterialProperty.h
        /// Colors are supported starting in macOS 10.12 and iOS 10. Prior to that you can use SCNView.backgroundColor.
        /// MDLSkyCubeTexture is supported starting in macOS 10.13 and iOS 11.
        #[unsafe(method(background))]
        #[unsafe(method_family = none)]
        pub unsafe fn background(&self) -> Retained<SCNMaterialProperty>;

        #[cfg(feature = "SCNMaterialProperty")]
        /// Specifies the receiver's environment for image-based lighting (IBL).
        ///
        /// The environment can be
        /// - a cube map (as described in SCNMaterialProperty.h)
        /// - an instance of `MDLSkyCubeTexture` (supported since macOS 10.13 and iOS 11)
        /// - an object returned by `+[SCNMaterialProperty precomputedLightingEnvironmentContentsWithURL:error:]` or `+[SCNMaterialProperty precomputedLightingEnvironmentContentsWithData:error:]`
        #[unsafe(method(lightingEnvironment))]
        #[unsafe(method_family = none)]
        pub unsafe fn lightingEnvironment(&self) -> Retained<SCNMaterialProperty>;

        /// Creates and returns a scene associated with the specified filename.
        ///
        /// Parameter `name`: The name of the file. The method looks for a file with the specified name in the application’s main bundle.
        ///
        /// This method initializes with no options and does not check for errors. The resulting object is not cached.
        #[unsafe(method(sceneNamed:))]
        #[unsafe(method_family = none)]
        pub unsafe fn sceneNamed(name: &NSString) -> Option<Retained<Self>>;

        #[cfg(feature = "SCNSceneSource")]
        /// Creates and returns a scene associated with the specified filename.
        ///
        /// Parameter `name`: The name of the file. The method looks for a file with the specified name in the application’s main bundle.
        ///
        /// Parameter `directory`: The name of the bundle sub-directory to search into.
        ///
        /// Parameter `options`: An options dictionary. The relevant keys are documented in the SCNSceneSource class.
        ///
        /// This method initializes with no options and does not check for errors. The resulting object is not cached.
        #[unsafe(method(sceneNamed:inDirectory:options:))]
        #[unsafe(method_family = none)]
        pub unsafe fn sceneNamed_inDirectory_options(
            name: &NSString,
            directory: Option<&NSString>,
            options: Option<&NSDictionary<SCNSceneSourceLoadingOption, AnyObject>>,
        ) -> Option<Retained<Self>>;

        #[cfg(feature = "SCNSceneSource")]
        /// Creates and returns a scene from the specified URL.
        ///
        /// Parameter `url`: The URL to the 3D file.
        ///
        /// Parameter `options`: An options dictionary. The relevant keys are documented in the SCNSceneSource class.
        ///
        /// Parameter `error`: A NSError object passed by reference to get more information about the error when a nil is returned.
        ///
        /// This method is here for convenience. It is equivalent to initializing a SCNSceneSource with the specified
        /// url and options, and asking it for its scene with the same options.
        #[unsafe(method(sceneWithURL:options:error:_))]
        #[unsafe(method_family = none)]
        pub unsafe fn sceneWithURL_options_error(
            url: &NSURL,
            options: Option<&NSDictionary<SCNSceneSourceLoadingOption, AnyObject>>,
        ) -> Result<Retained<Self>, Retained<NSError>>;

        #[cfg(feature = "block2")]
        /// write the scene to the specified url.
        ///
        /// Parameter `url`: the destination url to write the scene to.
        ///
        /// Parameter `options`: A dictionary of options. The valid keys are described in the "Scene writing options" section.
        ///
        /// Parameter `delegate`: an optional delegate to manage external references such as images.
        ///
        /// Parameter `progressHandler`: an optional block to handle the progress of the operation.
        ///
        /// Returns: Returns YES if the operation succeeded, NO otherwise. Errors checking can be done via the "error"
        /// parameter of the 'progressHandler'.
        ///
        /// macOS 10.10 and lower only supports exporting to .dae files.
        /// Starting macOS 10.11 exporting supports .dae, .scn as well as file all formats supported by Model I/O.
        /// Starting iOS 10 exporting supports .scn as well as all file formats supported by Model I/O.
        #[unsafe(method(writeToURL:options:delegate:progressHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn writeToURL_options_delegate_progressHandler(
            &self,
            url: &NSURL,
            options: Option<&NSDictionary<NSString, AnyObject>>,
            delegate: Option<&ProtocolObject<dyn SCNSceneExportDelegate>>,
            progress_handler: SCNSceneExportProgressHandler,
        ) -> bool;

        #[cfg(feature = "objc2-core-foundation")]
        /// Specifies the receiver's fog start distance. Animatable. Defaults to 0.
        #[unsafe(method(fogStartDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn fogStartDistance(&self) -> CGFloat;

        #[cfg(feature = "objc2-core-foundation")]
        /// Setter for [`fogStartDistance`][Self::fogStartDistance].
        #[unsafe(method(setFogStartDistance:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFogStartDistance(&self, fog_start_distance: CGFloat);

        #[cfg(feature = "objc2-core-foundation")]
        /// Specifies the receiver's fog end distance. Animatable. Defaults to 0.
        #[unsafe(method(fogEndDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn fogEndDistance(&self) -> CGFloat;

        #[cfg(feature = "objc2-core-foundation")]
        /// Setter for [`fogEndDistance`][Self::fogEndDistance].
        #[unsafe(method(setFogEndDistance:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFogEndDistance(&self, fog_end_distance: CGFloat);

        #[cfg(feature = "objc2-core-foundation")]
        /// Specifies the receiver's fog power exponent. Animatable. Defaults to 1.
        ///
        /// Controls the attenuation between the start and end fog distances. 0 means a constant fog, 1 a linear fog and 2 a quadratic fog, but any positive value will work.
        #[unsafe(method(fogDensityExponent))]
        #[unsafe(method_family = none)]
        pub unsafe fn fogDensityExponent(&self) -> CGFloat;

        #[cfg(feature = "objc2-core-foundation")]
        /// Setter for [`fogDensityExponent`][Self::fogDensityExponent].
        #[unsafe(method(setFogDensityExponent:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFogDensityExponent(&self, fog_density_exponent: CGFloat);

        /// Specifies the receiver's fog color (NSColor or CGColorRef). Animatable. Defaults to white.
        ///
        /// The initial value is a NSColor.
        #[unsafe(method(fogColor))]
        #[unsafe(method_family = none)]
        pub unsafe fn fogColor(&self) -> Retained<AnyObject>;

        /// Setter for [`fogColor`][Self::fogColor].
        #[unsafe(method(setFogColor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFogColor(&self, fog_color: &AnyObject);

        /// Determines if the scene use screen space reflection.
        ///
        /// Defaults to NO.
        #[unsafe(method(wantsScreenSpaceReflection))]
        #[unsafe(method_family = none)]
        pub unsafe fn wantsScreenSpaceReflection(&self) -> bool;

        /// Setter for [`wantsScreenSpaceReflection`][Self::wantsScreenSpaceReflection].
        #[unsafe(method(setWantsScreenSpaceReflection:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setWantsScreenSpaceReflection(&self, wants_screen_space_reflection: bool);

        /// Determines the sample count of the screen space reflection.
        ///
        /// Defaults to 64.
        #[unsafe(method(screenSpaceReflectionSampleCount))]
        #[unsafe(method_family = none)]
        pub unsafe fn screenSpaceReflectionSampleCount(&self) -> NSInteger;

        /// Setter for [`screenSpaceReflectionSampleCount`][Self::screenSpaceReflectionSampleCount].
        #[unsafe(method(setScreenSpaceReflectionSampleCount:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setScreenSpaceReflectionSampleCount(
            &self,
            screen_space_reflection_sample_count: NSInteger,
        );

        #[cfg(feature = "objc2-core-foundation")]
        /// Determines the maximum distance in world units.
        ///
        /// Defaults to 1000.
        #[unsafe(method(screenSpaceReflectionMaximumDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn screenSpaceReflectionMaximumDistance(&self) -> CGFloat;

        #[cfg(feature = "objc2-core-foundation")]
        /// Setter for [`screenSpaceReflectionMaximumDistance`][Self::screenSpaceReflectionMaximumDistance].
        #[unsafe(method(setScreenSpaceReflectionMaximumDistance:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setScreenSpaceReflectionMaximumDistance(
            &self,
            screen_space_reflection_maximum_distance: CGFloat,
        );

        #[cfg(feature = "objc2-core-foundation")]
        /// Raytracing step size in pixel. The lower the better, the higher the faster.
        ///
        /// Defaults to 8.
        #[unsafe(method(screenSpaceReflectionStride))]
        #[unsafe(method_family = none)]
        pub unsafe fn screenSpaceReflectionStride(&self) -> CGFloat;

        #[cfg(feature = "objc2-core-foundation")]
        /// Setter for [`screenSpaceReflectionStride`][Self::screenSpaceReflectionStride].
        #[unsafe(method(setScreenSpaceReflectionStride:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setScreenSpaceReflectionStride(
            &self,
            screen_space_reflection_stride: CGFloat,
        );

        /// Controls whether or not the scene is paused. Defaults to NO.
        ///
        /// Pausing a scene will pause animations, actions, particles and physics.
        #[unsafe(method(isPaused))]
        #[unsafe(method_family = none)]
        pub unsafe fn isPaused(&self) -> bool;

        /// Setter for [`isPaused`][Self::isPaused].
        #[unsafe(method(setPaused:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPaused(&self, paused: bool);
    );
}

/// Methods declared on superclass `NSObject`.
impl SCNScene {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_protocol!(
    /// [Apple's documentation](https://developer.apple.com/documentation/scenekit/scnsceneexportdelegate?language=objc)
    pub unsafe trait SCNSceneExportDelegate: NSObjectProtocol {
        #[cfg(feature = "objc2-app-kit")]
        #[cfg(target_os = "macos")]
        /// Invoked on the delegate to write the referenced image and return the destination url.
        ///
        /// Parameter `image`: The image to write.
        ///
        /// Parameter `documentURL`: The url where the scene is currently exported to.
        ///
        /// Parameter `originalImageURL`: The original url for the image. May be nil if the image was not previously loaded from a url.
        ///
        /// Returns: The delegate must returns the url of the image that was exported or nil if it didn't export any image. If the returned value is nil, the image will be exported to a default destination in a default format.
        #[optional]
        #[unsafe(method(writeImage:withSceneDocumentURL:originalImageURL:))]
        #[unsafe(method_family = none)]
        unsafe fn writeImage_withSceneDocumentURL_originalImageURL(
            &self,
            image: &NSImage,
            document_url: &NSURL,
            original_image_url: Option<&NSURL>,
        ) -> Option<Retained<NSURL>>;
    }
);