xamarin-macios/src/scenekit.cs

///
// Authors:
//  Miguel de Icaza (miguel@xamarin.com)
//  Aaron Bockover (abock@xamarin.com)
//
// Copyright 2012-2014 Xamarin, Inc.
//
// TODO:
//
//   SpriteKit needs porting to Mac (see SCNSceneRenderer.OverlayScene)
//
//   SCNSceneSource's propertyForKey: takes a series of constants,
//   perhaps we should just hide that with strongly typed values, and
//   not even expose the keys.
//
//   Strong types SCNSceneSource's init options
//
//   Review docs for "nil" to annotate the various nulls.
//
//   Strongly typed dictionary support:
//     - SCNTechnique:
//       This one requires a strong type with nested components to produce the dictionary
//       it is not very obvious.
//     - SCNPhysicsShape (VERY IMPORTANT)
//     - SCNParticleSystem (not important)
//

using System;
using System.ComponentModel;
using System.Diagnostics;

using AVFoundation;
using CoreFoundation;
using Foundation;
using ObjCRuntime;

using NMatrix4 = global::OpenTK.NMatrix4;
using NVector3 = global::OpenTK.NVector3;
using Vector4 = global::OpenTK.Vector4;
using Quaternion = global::OpenTK.Quaternion;

#if !WATCH
using CoreAnimation;
using CoreImage;
#endif

#if WATCH || XAMCORE_4_0
using AnimationType = global::SceneKit.ISCNAnimationProtocol;
#else
using AnimationType = global::CoreAnimation.CAAnimation;
#endif

using CoreGraphics;
using SpriteKit;
// MonoMac (classic) does not support those 64bits only frameworks
#if (XAMCORE_2_0 || !MONOMAC) && !WATCH
using ModelIO;
using Metal;
using GameplayKit;
#endif

#if MONOMAC
using AppKit;
using OpenTK;

using GLContext = global::OpenGL.CGLContext;
#else
using UIKit;

#if WATCH
using GLContext = global::Foundation.NSObject; // won't be used -> [NoWatch] but must compile
using NSView = global::Foundation.NSObject; // won't be used -> [NoWatch] but must compile
using SCNGeometryTessellator = global::Foundation.NSObject; // won't be used -> [NoWatch] but must compile
#else
using OpenGLES;

using GLContext = global::OpenGLES.EAGLContext;
using NSView = global::UIKit.UIView;
#endif

using NSColor = global::UIKit.UIColor;
using NSFont = global::UIKit.UIFont;
using NSImage = global::UIKit.UIImage;
using NSBezierPath = global::UIKit.UIBezierPath;
#endif

namespace SceneKit {

#if WATCH
	// stubs to limit the number of preprocessor directives in the source file
	interface CAAnimation {}
	interface CALayer {}
	interface CAMediaTimingFunction {}
	interface MDLAsset {}
	interface MDLCamera {}
	interface MDLLight {}
	interface MDLMaterial {}
	interface MDLMesh {}
	interface MDLObject {}
	interface MDLSubmesh {}
	enum MTLPixelFormat {}
	enum MTLVertexFormat {}
	interface IMTLBuffer {}
	interface IMTLCommandBuffer {}
	interface IMTLCommandQueue {}
	interface IMTLDevice {}
	interface IMTLLibrary {}
	interface IMTLRenderCommandEncoder {}
	interface MTLRenderPassDescriptor {}
#endif

	[iOS (8,0)]
	delegate void SCNSceneSourceStatusHandler (float /* float, not CGFloat */ totalProgress, SCNSceneSourceStatus status, NSError error, ref bool stopLoading);

	delegate void SCNAnimationDidStartHandler (SCNAnimation animation, SCNAnimatable receiver);
	delegate void SCNAnimationDidStopHandler (SCNAnimation animation, SCNAnimatable receiver, bool completed);

	[Watch (3,0)]
	[iOS (8,0)]
	[Model, Protocol]
	[BaseType (typeof (NSObject))]
	interface SCNAnimatable {
#if XAMCORE_2_0
		[Abstract]
#endif
		[NoWatch]
		[Export ("addAnimation:forKey:")]
#if !XAMCORE_4_0
		void AddAnimation (CAAnimation animation, [NullAllowed] NSString key);
#else
		void AddAnimation (ISCNAnimationProtocol scnAnimation, [NullAllowed] string key);
#endif

#if XAMCORE_2_0
#if XAMCORE_4_0
		[Abstract]
#endif
		[iOS (11,0), TV (11,0), Watch (4,0), Mac (10,13, onlyOn64: true)]
		[Export ("addAnimationPlayer:forKey:")]
		void AddAnimation (SCNAnimationPlayer player, [NullAllowed] NSString key);
#endif

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("removeAllAnimations")]
		void RemoveAllAnimations ();

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("removeAnimationForKey:")]
		void RemoveAnimation (NSString key);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("animationKeys")]
		NSString [] GetAnimationKeys ();

#if XAMCORE_2_0
#if XAMCORE_4_0
		[Abstract]
#endif
		[return: NullAllowed]
		[iOS (11,0), TV (11,0), Watch (4,0), Mac (10,13, onlyOn64: true)]
		[Export ("animationPlayerForKey:")]
		SCNAnimationPlayer GetAnimationPlayer (NSString key);
#endif

#if XAMCORE_2_0
		[Abstract]
#endif
		[Deprecated (PlatformName.TvOS, 11, 0,   message: "Use 'GetAnimationPlayer' instead.")]
		[Deprecated (PlatformName.iOS, 11, 0,    message: "Use 'GetAnimationPlayer' instead.")]
		[Deprecated (PlatformName.MacOSX, 10, 13,message: "Use 'GetAnimationPlayer' instead.")]
		[NoWatch]
		[Export ("animationForKey:")]
		CAAnimation GetAnimation (NSString key);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Deprecated (PlatformName.WatchOS, 4, 0, message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Deprecated (PlatformName.TvOS, 11, 0,   message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Deprecated (PlatformName.iOS, 11, 0,    message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Deprecated (PlatformName.MacOSX, 10, 13,message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Mac (10,9)]
		[Export ("pauseAnimationForKey:")]
		void PauseAnimation (NSString key);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Deprecated (PlatformName.WatchOS, 4, 0, message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Deprecated (PlatformName.TvOS, 11, 0,   message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Deprecated (PlatformName.iOS, 11, 0,    message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Deprecated (PlatformName.MacOSX, 10, 13,message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Mac (10,9)]
		[Export ("resumeAnimationForKey:")]
		void ResumeAnimation (NSString key);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Watch (3, 0)]
		[Deprecated (PlatformName.WatchOS, 4, 0, message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[TV (9, 0)]
		[Deprecated (PlatformName.TvOS, 11, 0,   message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[iOS (8, 0)]
		[Deprecated (PlatformName.iOS, 11, 0,    message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Mac (10, 9)]
		[Deprecated (PlatformName.MacOSX, 10, 13,message: "Use 'SCNAnimationPlayer.Paused' instead.")]
		[Export ("isAnimationForKeyPaused:")]
		bool IsAnimationPaused (NSString key);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Deprecated (PlatformName.WatchOS, 4, 0, message: "Use 'RemoveAnimationUsingBlendOutDuration' instead.")]
		[Deprecated (PlatformName.TvOS, 11, 0,   message: "Use 'RemoveAnimationUsingBlendOutDuration' instead.")]
		[Deprecated (PlatformName.iOS, 11, 0,    message: "Use 'RemoveAnimationUsingBlendOutDuration' instead.")]
		[Deprecated (PlatformName.MacOSX, 10, 13,message: "Use 'RemoveAnimationUsingBlendOutDuration' instead.")]
		[Mac (10,10)]
		[Export ("removeAnimationForKey:fadeOutDuration:")]
		void RemoveAnimation (NSString key, nfloat duration);

#if XAMCORE_4_0
		[Abstract]
#endif
		[return: NullAllowed]
		[iOS (11,0), TV (11,0), Watch (4,0), Mac (10,13, onlyOn64: true)]
		[Export ("removeAnimationForKey:blendOutDuration:")]
		void RemoveAnimationUsingBlendOutDuration (NSString key, nfloat blendOutDuration);

		[Deprecated (PlatformName.WatchOS, 4, 0, message: "Use 'SCNAnimationPlayer.Speed' instead.")]
		[Deprecated (PlatformName.TvOS, 11, 0,   message: "Use 'SCNAnimationPlayer.Speed' instead.")]
		[Deprecated (PlatformName.iOS, 11, 0,    message: "Use 'SCNAnimationPlayer.Speed' instead.")]
		[Deprecated (PlatformName.MacOSX, 10, 13,message: "Use 'SCNAnimationPlayer.Speed' instead.")]
		[TV (10, 0), Mac (10, 12), iOS (10, 0), Watch (3,0)]
		[Export ("setSpeed:forAnimationKey:")]
		void SetSpeed (nfloat speed, NSString key);
	}

	[Watch (3,0)]
	[iOS(9,0),Mac(10,11)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface SCNAudioPlayer
	{
		[Export ("initWithSource:")]
		[DesignatedInitializer]
		IntPtr Constructor (SCNAudioSource source);
	
		[Export ("initWithAVAudioNode:")]
		[DesignatedInitializer]
		IntPtr Constructor (AVAudioNode audioNode);
	
		[Static]
		[Export ("audioPlayerWithSource:")]
		SCNAudioPlayer FromSource (SCNAudioSource source);
	
		[Static]
		[Export ("audioPlayerWithAVAudioNode:")]
		SCNAudioPlayer AVAudioNode (AVAudioNode audioNode);
	
		[Export ("willStartPlayback")]
		Action WillStartPlayback { get; set; }
	
		[Export ("didFinishPlayback")]
		Action DidFinishPlayback { get; set; }
	
		[NullAllowed, Export ("audioNode")]
		AVAudioNode AudioNode { get; }
	
		[NullAllowed, Export ("audioSource")]
		SCNAudioSource AudioSource { get; }
	}
	
	[Watch (3,0)]
	[iOS (9,0), Mac(10,11)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface SCNAudioSource : NSCopying, NSSecureCoding
	{
		[Export ("initWithFileNamed:")]
		IntPtr Constructor (string filename);
	
		[Export ("initWithURL:")]
		[DesignatedInitializer]
		IntPtr Constructor (NSUrl url);
	
		[Static]
		[Export ("audioSourceNamed:")]
		SCNAudioSource FromFile (string fileName);
	
		[Export ("positional")]
		bool Positional { [Bind ("isPositional")] get; set; }
	

		[Export ("volume")]
		float Volume { get; set; }
	
		[Export ("rate")]
		float Rate { get; set; }
	
		[Export ("reverbBlend")]
		float ReverbBlend { get; set; }
	
		[Export ("loops")]
		bool Loops { get; set; }
	
		[Export ("shouldStream")]
		bool ShouldStream { get; set; }
	
		[Export ("load")]
		void Load ();
	}
		

	[Watch (3,0)]
	[iOS (8,0)]
	[Model, Protocol]
	[BaseType (typeof (NSObject))]
	interface SCNBoundingVolume {
#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("getBoundingBoxMin:max:")]
		bool GetBoundingBox (ref SCNVector3 min, ref SCNVector3 max);

		[Mac (10,9)] // Yep, Apple broke backwards compatibility in 10.9 by introducing a new required member.
		[Abstract]
		[Export ("setBoundingBoxMin:max:")]
		void SetBoundingBox (ref SCNVector3 min, ref SCNVector3 max);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("getBoundingSphereCenter:radius:")]
		bool GetBoundingSphere (ref SCNVector3 center, ref nfloat radius);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	interface SCNBox {
		[Export ("width")]
		nfloat Width { get; set;  }

		[Export ("height")]
		nfloat Height { get; set;  }

		[Export ("length")]
		nfloat Length { get; set;  }

		[Export ("chamferRadius")]
		nfloat ChamferRadius { get; set;  }

		[Export ("widthSegmentCount")]
		nint WidthSegmentCount { get; set;  }

		[Export ("heightSegmentCount")]
		nint HeightSegmentCount { get; set;  }

		[Export ("lengthSegmentCount")]
		nint LengthSegmentCount { get; set;  }

		[Export ("chamferSegmentCount")]
		nint ChamferSegmentCount { get; set;  }

		[Static, Export ("boxWithWidth:height:length:chamferRadius:")]
		SCNBox Create (nfloat width, nfloat height, nfloat length, nfloat chamferRadius);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNCamera : SCNAnimatable, SCNTechniqueSupport, NSCopying, NSSecureCoding {
		[NullAllowed] // by default this property is null
		[Export ("name", ArgumentSemantic.Copy)]
		string Name { get; set;  }

		[Deprecated (PlatformName.MacOSX, 10, 13, message: "Use 'FieldOfView' or 'FocalLength' instead.")]
		[Deprecated (PlatformName.iOS,    11, 0,  message: "Use 'FieldOfView' or 'FocalLength' instead.")]
		[Deprecated (PlatformName.TvOS,   11, 0,  message: "Use 'FieldOfView' or 'FocalLength' instead.")]
		[Deprecated (PlatformName.WatchOS, 4, 0,  message: "Use 'FieldOfView' or 'FocalLength' instead.")]
		[Export ("xFov")]
		double XFov { get; set;  }

		[Deprecated (PlatformName.MacOSX, 10, 13, message: "Use 'FieldOfView' or 'FocalLength' instead.")]
		[Deprecated (PlatformName.iOS,    11, 0,  message: "Use 'FieldOfView' or 'FocalLength' instead.")]
		[Deprecated (PlatformName.TvOS,   11, 0,  message: "Use 'FieldOfView' or 'FocalLength' instead.")]
		[Deprecated (PlatformName.WatchOS, 4, 0,  message: "Use 'FieldOfView' or 'FocalLength' instead.")]
		[Export ("yFov")]
		double YFov { get; set;  }

		[Export ("zNear")]
		double ZNear { get; set;  }

		[Export ("zFar")]
		double ZFar { get; set;  }

		[Export ("usesOrthographicProjection")]
		bool UsesOrthographicProjection { get; set;  }

		[Static, Export ("camera")]
		SCNCamera Create ();

		[iOS (8,0)][Mac (10,9)]
		[Export ("projectionTransform")]
		SCNMatrix4 ProjectionTransform { get; [Mac (10,9)] set; }

		[iOS (8,0)][Mac (10,9)]
		[Export ("automaticallyAdjustsZRange")]
		bool AutomaticallyAdjustsZRange { get; set; }
		
		[iOS (8,0)][Mac (10,9)]
		[Export ("orthographicScale")]
		double OrthographicScale { get; set; }

		[Deprecated (PlatformName.MacOSX, 10, 13, message: "Use 'FocusDistance' instead.")]
		[Deprecated (PlatformName.iOS,    11, 0,  message: "Use 'FocusDistance' instead.")]
		[Deprecated (PlatformName.TvOS,   11, 0,  message: "Use 'FocusDistance' instead.")]
		[Deprecated (PlatformName.WatchOS, 4, 0,  message: "Use 'FocusDistance' instead.")]
		[iOS (8,0)][Mac (10,9)]
		[Export ("focalDistance")]
		nfloat FocalDistance { get; set; }

		[Deprecated (PlatformName.MacOSX, 10, 13, message: "Use 'FocusDistance' instead.")]
		[Deprecated (PlatformName.iOS,    11, 0,  message: "Use 'FocusDistance' instead.")]
		[Deprecated (PlatformName.TvOS,   11, 0,  message: "Use 'FocusDistance' instead.")]
		[Deprecated (PlatformName.WatchOS, 4, 0,  message: "Use 'FocusDistance' instead.")]
		[iOS (8,0)][Mac (10,9)]
		[Export ("focalSize")]
		nfloat FocalSize { get; set; }

		[Deprecated (PlatformName.MacOSX, 10, 13, message: "Use 'FStop' instead.")]
		[Deprecated (PlatformName.iOS,    11, 0,  message: "Use 'FStop' instead.")]
		[Deprecated (PlatformName.TvOS,   11, 0,  message: "Use 'FStop' instead.")]
		[Deprecated (PlatformName.WatchOS, 4, 0,  message: "Use 'FStop' instead.")]
		[iOS (8,0)][Mac (10,9)]
		[Export ("focalBlurRadius")]
		nfloat FocalBlurRadius { get; set; }

		[Deprecated (PlatformName.MacOSX, 10, 13, message: "Use 'FStop' instead with FStop = SensorHeight / Aperture.")]
		[Deprecated (PlatformName.iOS,    11, 0,  message: "Use 'FStop' instead with FStop = SensorHeight / Aperture.")]
		[Deprecated (PlatformName.TvOS,   11, 0,  message: "Use 'FStop' instead with FStop = SensorHeight / Aperture.")]
		[Deprecated (PlatformName.WatchOS, 4, 0,  message: "Use 'FStop' instead with FStop = SensorHeight / Aperture.")]
		[iOS (8,0)][Mac (10,9)]
		[Export ("aperture")]
		nfloat Aperture { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("motionBlurIntensity")]
		nfloat MotionBlurIntensity { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("wantsHDR")]
		bool WantsHdr { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("exposureOffset")]
		nfloat ExposureOffset { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("averageGray")]
		nfloat AverageGray { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("whitePoint")]
		nfloat WhitePoint { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("wantsExposureAdaptation")]
		bool WantsExposureAdaptation { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("exposureAdaptationBrighteningSpeedFactor")]
		nfloat ExposureAdaptationBrighteningSpeedFactor { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("exposureAdaptationDarkeningSpeedFactor")]
		nfloat ExposureAdaptationDarkeningSpeedFactor { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("minimumExposure")]
		nfloat MinimumExposure { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("maximumExposure")]
		nfloat MaximumExposure { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("bloomThreshold")]
		nfloat BloomThreshold { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("bloomIntensity")]
		nfloat BloomIntensity { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("bloomBlurRadius")]
		nfloat BloomBlurRadius { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("vignettingPower")]
		nfloat VignettingPower { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("vignettingIntensity")]
		nfloat VignettingIntensity { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("colorFringeStrength")]
		nfloat ColorFringeStrength { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("colorFringeIntensity")]
		nfloat ColorFringeIntensity { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("saturation")]
		nfloat Saturation { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("contrast")]
		nfloat Contrast { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("colorGrading")]
		SCNMaterialProperty ColorGrading { get; }

		[iOS (8,0)][Mac (10,10)]
		[Export ("categoryBitMask")]
		nuint CategoryBitMask { get; set; }

#if XAMCORE_2_0
		[NoWatch]
		[iOS (9,0), Mac(10,11)]
		[Static]
		[Export ("cameraWithMDLCamera:")]
		SCNCamera FromModelCamera (MDLCamera modelCamera);

		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("fieldOfView")]
		nfloat FieldOfView { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("projectionDirection", ArgumentSemantic.Assign)]
		SCNCameraProjectionDirection ProjectionDirection { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("focalLength")]
		nfloat FocalLength { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("sensorHeight")]
		nfloat SensorHeight { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("wantsDepthOfField")]
		bool WantsDepthOfField { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("focusDistance")]
		nfloat FocusDistance { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("focalBlurSampleCount")]
		nint FocalBlurSampleCount { get; set; }

		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("fStop")]
		nfloat FStop { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("apertureBladeCount")]
		nint ApertureBladeCount { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("screenSpaceAmbientOcclusionIntensity")]
		nfloat ScreenSpaceAmbientOcclusionIntensity { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("screenSpaceAmbientOcclusionRadius")]
		nfloat ScreenSpaceAmbientOcclusionRadius { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("screenSpaceAmbientOcclusionBias")]
		nfloat ScreenSpaceAmbientOcclusionBias { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("screenSpaceAmbientOcclusionDepthThreshold")]
		nfloat ScreenSpaceAmbientOcclusionDepthThreshold { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("screenSpaceAmbientOcclusionNormalThreshold")]
		nfloat ScreenSpaceAmbientOcclusionNormalThreshold { get; set; }

#endif
	}

	interface ISCNCameraControlConfiguration {}

	[NoWatch]
	[TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
	[Protocol]
	interface SCNCameraControlConfiguration
	{
		[Abstract]
		[Export ("autoSwitchToFreeCamera")]
		bool AutoSwitchToFreeCamera { get; set; }
	
		[Abstract]
		[Export ("allowsTranslation")]
		bool AllowsTranslation { get; set; }
	
		[Abstract]
		[Export ("flyModeVelocity")]
		nfloat FlyModeVelocity { get; set; }
	
		[Abstract]
		[Export ("panSensitivity")]
		nfloat PanSensitivity { get; set; }
	
		[Abstract]
		[Export ("truckSensitivity")]
		nfloat TruckSensitivity { get; set; }
	
		[Abstract]
		[Export ("rotationSensitivity")]
		nfloat RotationSensitivity { get; set; }
	}

	interface ISCNCameraControllerDelegate {}
	
	[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
	[Protocol]
	[Model] // Figured I would keep the model for convenience, as all the methods here are optional
	[BaseType (typeof(NSObject))]
	interface SCNCameraControllerDelegate
	{
		[Export ("cameraInertiaWillStartForController:")]
		void CameraInertiaWillStart (SCNCameraController cameraController);
	
		[Export ("cameraInertiaDidEndForController:")]
		void CameraInertiaDidEnd (SCNCameraController cameraController);
	}
	
	[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof(NSObject))]
	interface SCNCameraController
	{
		[Export ("delegate", ArgumentSemantic.Assign)]
		[NullAllowed]
		[Protocolize]
		SCNCameraControllerDelegate Delegate { get; set; }
	
		[NullAllowed, Export ("pointOfView", ArgumentSemantic.Retain)]
		SCNNode PointOfView { get; set; }
	
		[Export ("interactionMode", ArgumentSemantic.Assign)]
		SCNInteractionMode InteractionMode { get; set; }
	
		[Export ("target", ArgumentSemantic.Assign)]
		SCNVector3 Target { get; set; }
	
		[Export ("automaticTarget")]
		bool AutomaticTarget { get; set; }
	
		[Export ("worldUp", ArgumentSemantic.Assign)]
		SCNVector3 WorldUp { get; set; }
	
		[Export ("inertiaEnabled")]
		bool InertiaEnabled { get; set; }

		[Export ("inertiaFriction")]
		float InertiaFriction { get; set; }
	
		[Export ("inertiaRunning")]
		bool InertiaRunning { [Bind ("isInertiaRunning")] get; }
	
		[Export ("minimumVerticalAngle")]
		float MinimumVerticalAngle { get; set; }
	
		[Export ("maximumVerticalAngle")]
		float MaximumVerticalAngle { get; set; }
	
		[Export ("minimumHorizontalAngle")]
		float MinimumHorizontalAngle { get; set; }
	
		[Export ("maximumHorizontalAngle")]
		float MaximumHorizontalAngle { get; set; }
	
		[Export ("translateInCameraSpaceByX:Y:Z:")]
		void TranslateInCameraSpace (float deltaX, float deltaY, float deltaZ);
	
		[Export ("frameNodes:")]
		void FrameNodes (SCNNode[] nodes);
	
		[Export ("rotateByX:Y:")]
		void Rotate (float deltaX, float deltaY);
	
		[Export ("rollBy:aroundScreenPoint:viewport:")]
		void Roll (float delta, CGPoint screenPoint, CGSize viewport);
	
		[Export ("dollyBy:onScreenPoint:viewport:")]
		void Dolly (float delta, CGPoint screenPoint, CGSize viewport);
	
		[Export ("rollAroundTarget:")]
		void RollAroundTarget (float delta);
	
		[Export ("dollyToTarget:")]
		void DollyToTarget (float delta);
	
		[Export ("clearRoll")]
		void ClearRoll ();
	
		[Export ("stopInertia")]
		void StopInertia ();
	
		[Export ("beginInteraction:withViewport:")]
		void BeginInteraction (CGPoint location, CGSize viewport);
	
		[Export ("continueInteraction:withViewport:sensitivity:")]
		void ContinueInteraction (CGPoint location, CGSize viewport, nfloat sensitivity);
	
		[Export ("endInteraction:withViewport:velocity:")]
		void EndInteraction (CGPoint location, CGSize viewport, CGPoint velocity);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	interface SCNCapsule {
		[Export ("capRadius")]
		nfloat CapRadius { get; set;  }

		[Export ("height")]
		nfloat Height { get; set;  }

		[Export ("radialSegmentCount")]
		nint RadialSegmentCount { get; set;  }

		[Export ("heightSegmentCount")]
		nint HeightSegmentCount { get; set;  }

		[Export ("capSegmentCount")]
		nint CapSegmentCount { get; set;  }

		[Static, Export ("capsuleWithCapRadius:height:")]
		SCNCapsule Create (nfloat capRadius, nfloat height);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	interface SCNCone {
		[Export ("topRadius")]
		nfloat TopRadius { get; set;  }

		[Export ("bottomRadius")]
		nfloat BottomRadius { get; set;  }

		[Export ("height")]
		nfloat Height { get; set;  }

		[Export ("radialSegmentCount")]
		nint RadialSegmentCount { get; set;  }

		[Export ("heightSegmentCount")]
		nint HeightSegmentCount { get; set;  }

		[Static, Export ("coneWithTopRadius:bottomRadius:height:")]
		SCNCone Create (nfloat topRadius, nfloat bottomRadius, nfloat height);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	interface SCNCylinder {
		[Export ("radius")]
		nfloat Radius { get; set;  }

		[Export ("height")]
		nfloat Height { get; set;  }

		[Export ("radialSegmentCount")]
		nint RadialSegmentCount { get; set;  }

		[Export ("heightSegmentCount")]
		nint HeightSegmentCount { get; set;  }

		[Static, Export ("cylinderWithRadius:height:")]
		SCNCylinder Create (nfloat radius, nfloat height);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	interface SCNFloor {
		[Export ("reflectivity")]
		nfloat Reflectivity { get; set;  }

		[Export ("reflectionFalloffStart")]
		nfloat ReflectionFalloffStart { get; set;  }

		[Export ("reflectionFalloffEnd")]
		nfloat ReflectionFalloffEnd { get; set;  }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("reflectionCategoryBitMask")]
		nuint ReflectionCategoryBitMask { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("width")]
		nfloat Width { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("length")]
		nfloat Length { get; set; }

		[Mac (10,10)]
		[Export ("reflectionResolutionScaleFactor")]
		nfloat ReflectionResolutionScaleFactor { get; set; }

		[Static, Export ("floor")]
		SCNFloor Create ();
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor] 
	interface SCNGeometry : SCNAnimatable, SCNBoundingVolume, SCNShadable, NSCopying, NSSecureCoding {
		[Export ("materials", ArgumentSemantic.Copy)]
		SCNMaterial [] Materials { get; set;  }

		[Export ("geometryElementCount")]
		nint GeometryElementCount { get;  }

		[Export ("firstMaterial", ArgumentSemantic.Retain)]
		SCNMaterial FirstMaterial { get; set;  }

		[iOS (9,0)][Mac(10,11)] // header mistake (10,10) as tests shows it does not exists
		[Export ("geometryElements")]
		SCNGeometryElement [] GeometryElements { get; }

		[iOS (9,0)][Mac(10,11)] // header mistake (10,10) as tests shows it does not exists
		[Export ("geometrySources")]
		SCNGeometrySource [] GeometrySources { get; }
		
		[NullAllowed] // by default this property is null
		[Export ("name", ArgumentSemantic.Copy)]
		string Name { get; set; } 

		[Export ("insertMaterial:atIndex:")]
		void InsertMaterial (SCNMaterial material, nint index);

		[Export ("removeMaterialAtIndex:")]
		void RemoveMaterial (nint index);

		[Export ("replaceMaterialAtIndex:withMaterial:")]
		void ReplaceMaterial (nint materialIndex, SCNMaterial newMaterial);

		[Export ("materialWithName:")]
		SCNMaterial GetMaterial (string name);

		[Static]
		[Export ("geometryWithSources:elements:")]
		SCNGeometry Create (SCNGeometrySource [] sources, [NullAllowed] SCNGeometryElement [] elements);
	
		[Export ("geometrySourcesForSemantic:")]
		SCNGeometrySource [] GetGeometrySourcesForSemantic (string semantic);

		[Export ("geometryElementAtIndex:")]
		SCNGeometryElement GetGeometryElement (nint elementIndex);

		[Mac (10,9)]
		[NullAllowed] // by default this property is null
		[Export ("levelsOfDetail", ArgumentSemantic.Copy)]
		SCNLevelOfDetail [] LevelsOfDetail { get; set; }

		[Mac (10,9)]
		[Static, Export ("geometry")]
		SCNGeometry Create ();

		[Mac (10,10)]
		[Export ("subdivisionLevel")]
		nuint SubdivisionLevel { get; set; }

		[Mac (10,10)]
		[NullAllowed] // by default this property is null
		[Export ("edgeCreasesElement", ArgumentSemantic.Retain)]
		SCNGeometryElement EdgeCreasesElement { get; set; }

		[Mac (10,10)]
		[NullAllowed] // by default this property is null
		[Export ("edgeCreasesSource", ArgumentSemantic.Retain)]
		SCNGeometrySource EdgeCreasesSource { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("wantsAdaptiveSubdivision")]
		bool WantsAdaptiveSubdivision { get; set; }

#if XAMCORE_2_0
		[NoWatch]
		[iOS (9,0), Mac(10,11)]
		[Static]
		[Export ("geometryWithMDLMesh:")]
		SCNGeometry FromMesh (MDLMesh mesh);

		[NoWatch, Mac (10,13, onlyOn64: true), iOS (11,0)]
		[TV (12,0)]
		[NullAllowed, Export ("tessellator", ArgumentSemantic.Retain)]
		SCNGeometryTessellator Tessellator { get; set; }
#endif
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNGeometrySource : NSSecureCoding {
		[Export ("data")]
		NSData Data { get;  }

		[Export ("semantic")]
		NSString Semantic { get;  }

		[Export ("vectorCount")]
		nint VectorCount { get;  }

		[Export ("floatComponents")]
		bool FloatComponents { get;  }

		[Export ("componentsPerVector")]
		nint ComponentsPerVector { get;  }

		[Export ("bytesPerComponent")]
		nint BytesPerComponent { get;  }

		[Export ("dataOffset")]
		nint DataOffset { get;  }

		[Export ("dataStride")]
		nint DataStride { get;  }

		[Export ("geometrySourceWithData:semantic:vectorCount:floatComponents:componentsPerVector:bytesPerComponent:dataOffset:dataStride:")]
		[Static]
		SCNGeometrySource FromData (NSData data, NSString geometrySourceSemantic, nint vectorCount, bool floatComponents, nint componentsPerVector, nint bytesPerComponent, nint offset, nint stride);

		[Static]
		[Export ("geometrySourceWithVertices:count:"), Internal]
		SCNGeometrySource FromVertices (IntPtr vertices, nint count);

		[Static]
		[Export ("geometrySourceWithNormals:count:"), Internal]
		SCNGeometrySource FromNormals (IntPtr normals, nint count);

		[Static]
		[Export ("geometrySourceWithTextureCoordinates:count:"), Internal]
		SCNGeometrySource FromTextureCoordinates (IntPtr texcoords, nint count);

#if XAMCORE_2_0 || !MONOMAC
		[NoWatch]
		[iOS (9,0)][Mac (10,11)]
		[Static]
		[Export ("geometrySourceWithBuffer:vertexFormat:semantic:vertexCount:dataOffset:dataStride:")]
		SCNGeometrySource FromMetalBuffer (IMTLBuffer mtlBuffer, MTLVertexFormat vertexFormat, NSString geometrySourceSemantic, nint vertexCount, nint offset, nint stride);
#endif
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[Static]
	interface SCNGeometrySourceSemantic {
		[Field ("SCNGeometrySourceSemanticVertex")]
		NSString Vertex { get; }
		
		[Field ("SCNGeometrySourceSemanticNormal")]
		NSString Normal { get; }
		
		[Field ("SCNGeometrySourceSemanticColor")]
		NSString Color { get; }
		
		[Field ("SCNGeometrySourceSemanticTexcoord")]
		NSString Texcoord { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Field ("SCNGeometrySourceSemanticTangent")]
		NSString Tangent { get; }

		[Mac (10,10)]
		[Field ("SCNGeometrySourceSemanticVertexCrease")]
		NSString VertexCrease { get; }

		[Mac (10,10)]
		[Field ("SCNGeometrySourceSemanticEdgeCrease")]
		NSString EdgeCrease { get; }

		[Mac (10,10)]
		[Field ("SCNGeometrySourceSemanticBoneWeights")]
		NSString BoneWeights { get; }

		[Mac (10,10)]
		[Field ("SCNGeometrySourceSemanticBoneIndices")]
		NSString BoneIndices { get; }
	}
	
	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNGeometryElement : NSSecureCoding {
		[Export ("data")]
		NSData Data { get;  }

		[Export ("primitiveType")]
		SCNGeometryPrimitiveType PrimitiveType { get;  }

		[Export ("primitiveCount")]
		nint PrimitiveCount { get;  }

		[Export ("bytesPerIndex")]
		nint BytesPerIndex { get;  }

		[Static]
		[Export ("geometryElementWithData:primitiveType:primitiveCount:bytesPerIndex:")]
		SCNGeometryElement FromData ([NullAllowed] NSData data, SCNGeometryPrimitiveType primitiveType, nint primitiveCount, nint bytesPerIndex);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("primitiveRange", ArgumentSemantic.Assign)]
		NSRange PrimitiveRange { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("pointSize")]
		nfloat PointSize { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("minimumPointScreenSpaceRadius")]
		nfloat MinimumPointScreenSpaceRadius { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("maximumPointScreenSpaceRadius")]
		nfloat MaximumPointScreenSpaceRadius { get; set; }

#if XAMCORE_2_0
		[NoWatch]
		[iOS (9,0), Mac(10,11)]
		[Static]
		[Export ("geometryElementWithMDLSubmesh:")]
		SCNGeometryElement FromSubmesh (MDLSubmesh submesh);
#endif
	}

#if XAMCORE_2_0 && !WATCH
	[NoWatch, Mac (10, 13, onlyOn64: true), iOS (11,0)]
	[TV (12,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface SCNGeometryTessellator : NSCopying, NSSecureCoding
	{
		[Export ("tessellationFactorScale")]
		nfloat TessellationFactorScale { get; set; }
	
		[Export ("tessellationPartitionMode", ArgumentSemantic.Assign)]
		MTLTessellationPartitionMode TessellationPartitionMode { get; set; }
	
		[Export ("adaptive")]
		bool Adaptive { [Bind ("isAdaptive")] get; set; }
	
		[Export ("screenSpace")]
		bool ScreenSpace { [Bind ("isScreenSpace")] get; set; }
	
		[Export ("edgeTessellationFactor")]
		nfloat EdgeTessellationFactor { get; set; }
	
		[Export ("insideTessellationFactor")]
		nfloat InsideTessellationFactor { get; set; }
	
		[Export ("maximumEdgeLength")]
		nfloat MaximumEdgeLength { get; set; }
	
		[Export ("smoothingMode", ArgumentSemantic.Assign)]
		SCNTessellationSmoothingMode SmoothingMode { get; set; }
	}
#endif
	
	[Watch (3,0)]
	[iOS (8,0)]
	[Static]
	interface SCNHitTest {
		[Field ("SCNHitTestFirstFoundOnlyKey")]
		NSString FirstFoundOnlyKey { get; }
		
		[Field ("SCNHitTestSortResultsKey")]
		NSString SortResultsKey { get; }
		
		[Field ("SCNHitTestClipToZRangeKey")]
		NSString ClipToZRangeKey { get; }
		
		[Field ("SCNHitTestBackFaceCullingKey")]
		NSString BackFaceCullingKey { get; }
		
		[Field ("SCNHitTestBoundingBoxOnlyKey")]
		NSString BoundingBoxOnlyKey { get; }
		
		[Field ("SCNHitTestIgnoreChildNodesKey")]
		NSString IgnoreChildNodesKey { get; }
		
		[Field ("SCNHitTestRootNodeKey")]
		NSString RootNodeKey { get; }

		[Mac (10,9), iOS (8,0)]
		[Field ("SCNHitTestIgnoreHiddenNodesKey")]
		NSString IgnoreHiddenNodesKey { get; }

#if !XAMCORE_2_0 // Less preferred name, but let's not break stable API
		[Mac (10,9), iOS (8,0)]
		[Obsolete ("Use IgnoreHiddenNodesKey")]
		[Field ("SCNHitTestIgnoreHiddenNodesKey")]
		NSString IgnoreHiddenNodes { get; }
#endif
		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Field ("SCNHitTestOptionCategoryBitMask")]
		NSString OptionCategoryBitMaskKey { get; }

#if !XAMCORE_4_0
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Obsolete ("Use 'SearchModeKey' instead.")]
		[Field ("SCNHitTestOptionSearchMode")]
		NSString OptionSearchModeKey { get; }
#endif

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Field ("SCNHitTestOptionSearchMode")]
		NSString SearchModeKey { get; }
	}
	
	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	// quote: The SCNHitTestResult class is exposed as the return object from the hitTest:options: method, as an array of SCNHitTestResult objects.
	[DisableDefaultCtor] // crash when calling description
	interface SCNHitTestResult {
		[Export ("geometryIndex")]
		nint GeometryIndex { get;  }

		[Export ("faceIndex")]
		nint FaceIndex { get;  }

		[Export ("localCoordinates")]
		SCNVector3 LocalCoordinates { get;  }

		[Export ("worldCoordinates")]
		SCNVector3 WorldCoordinates { get;  }

		[Export ("localNormal")]
		SCNVector3 LocalNormal { get;  }

		[Export ("worldNormal")]
		SCNVector3 WorldNormal { get;  }

		[Export ("modelTransform")]
		SCNMatrix4 ModelTransform { get;  }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("boneNode")]
		SCNNode BoneNode { get; }

		[Export ("node")]
		SCNNode Node { get; }

		[Export ("textureCoordinatesWithMappingChannel:")]
		CGPoint GetTextureCoordinatesWithMappingChannel (nint channel);
	}

#if MONOMAC
	[iOS (8,0)]
	[BaseType (typeof (CAOpenGLLayer))]
	interface SCNLayer : SCNSceneRenderer, SCNTechniqueSupport {
//		We already pull in the Scene property from the SCNSceneRenderer protocol, no need to redefine it here.
//		[Export ("scene", ArgumentSemantic.Retain)]
//		SCNScene Scene { get; set;  }
	}
#endif

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNLight : SCNAnimatable, SCNTechniqueSupport, NSCopying, NSSecureCoding {
		[Export ("type", ArgumentSemantic.Copy)]
		NSString LightType { get; set;  }

		[Export ("color", ArgumentSemantic.Retain)]
		NSObject WeakColor { get; set; }

		[Wrap ("WeakColor")]
		NSColor Color { get; set;  }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("temperature")]
		nfloat Temperature { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("intensity")]
		nfloat Intensity { get; set; }

		[NullAllowed] // by default this property is null
		[Export ("name", ArgumentSemantic.Copy)]
		string Name { get; set;  }

		[Export ("castsShadow")]
		bool CastsShadow { get; set;  }

		[Export ("shadowColor", ArgumentSemantic.Retain)]
		NSObject WeakShadowColor { get; set;  }

		[Wrap ("WeakShadowColor")]
		NSColor ShadowColor { get; set; }

		[Mac (10,10)]
		[Export ("shadowBias")]
		nfloat ShadowBias { get; set; }

		[Export ("shadowRadius")]
		nfloat ShadowRadius { get; set;  }

		[Static, Export ("light")]
		SCNLight Create ();

#if XAMCORE_3_0
		[Availability (Unavailable = Platform.iOS_Version)]
#elif !MONOMAC
		[Obsolete ("Do not use; this method only exist in macOS, not in iOS.")]
#endif
		[NoTV]
		[Availability (Deprecated = Platform.Mac_10_10)]
		[Export ("attributeForKey:")]
		NSObject GetAttribute (NSString lightAttribute);

#if XAMCORE_3_0
		[Availability (Unavailable = Platform.iOS_Version)]
#elif !MONOMAC
		[Obsolete ("Do not use; this method only exist in macOS, not in iOS.")]
#endif
		[NoTV]
		[Availability (Deprecated = Platform.Mac_10_10)]
		[Export ("setAttribute:forKey:")]
		void SetAttribute (NSObject value, NSString attribuetKey);

		[Mac (10,9)]
		[Export ("gobo")]
		SCNMaterialProperty Gobo { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[NullAllowed, Export ("IESProfileURL", ArgumentSemantic.Retain)]
		NSUrl IesProfileUrl { get; set; }

		[Mac (10,10)]
		[Export ("shadowMapSize")]
		CGSize ShadowMapSize { get; set; }

		[Mac (10,10)]
		[Export ("shadowSampleCount")]
		nuint ShadowSampleCount { get; set; }

		[Mac (10,10)]
		[Export ("shadowMode")]
		SCNShadowMode ShadowMode { get; set; }

		[Mac (10,10)]
		[Export ("attenuationStartDistance")]
		nfloat AttenuationStartDistance { get; set; }

		[Mac (10,10)]
		[Export ("attenuationEndDistance")]
		nfloat AttenuationEndDistance { get; set; }

		[Mac (10,10)]
		[Export ("attenuationFalloffExponent")]
		nfloat AttenuationFalloffExponent { get; set; }

		[Mac (10,10)]
		[Export ("spotInnerAngle")]
		nfloat SpotInnerAngle { get; set; }

		[Mac (10,10)]
		[Export ("spotOuterAngle")]
		nfloat SpotOuterAngle { get; set; }

		[Mac (10,10)]
		[Export ("orthographicScale")]
		nfloat OrthographicScale { get; set; }

		[Mac (10,10)]
		[Export ("zNear")]
		nfloat ZNear { get; set; }

		[Mac (10,10)]
		[Export ("zFar")]
		nfloat ZFar { get; set; }

		[Mac (10,10), iOS (8,0)]
		[Export ("categoryBitMask")]
		nuint CategoryBitMask { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("automaticallyAdjustsShadowProjection")]
		bool AutomaticallyAdjustsShadowProjection { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("maximumShadowDistance")]
		nfloat MaximumShadowDistance { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("forcesBackFaceCasters")]
		bool ForcesBackFaceCasters { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("sampleDistributedShadowMaps")]
		bool SampleDistributedShadowMaps { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("shadowCascadeCount")]
		nuint ShadowCascadeCount { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("shadowCascadeSplittingFactor")]
		nfloat ShadowCascadeSplittingFactor { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("sphericalHarmonicsCoefficients", ArgumentSemantic.Copy)]
		NSData SphericalHarmonicsCoefficients { get; }

#if XAMCORE_2_0
		[NoWatch]
		[iOS (9,0), Mac(10,11)]
		[Static]
		[Export ("lightWithMDLLight:")]
		SCNLight FromModelLight (MDLLight mdllight);
#endif
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[Static]
	interface SCNLightType {
		[Field ("SCNLightTypeAmbient")]
		NSString Ambient { get; }
		
		[Field ("SCNLightTypeOmni")]
		NSString Omni { get; }
		
		[Field ("SCNLightTypeDirectional")]
		NSString Directional { get; }
		
		[Field ("SCNLightTypeSpot")]
		NSString Spot { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Field ("SCNLightTypeIES")]
		NSString Ies { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Field ("SCNLightTypeProbe")]
		NSString Probe { get; }
	}

#if MONOMAC
	[Availability (Deprecated = Platform.Mac_10_10)]
	[Static]
	interface SCNLightAttribute {
		[Field ("SCNLightAttenuationStartKey")]
		NSString AttenuationStartKey { get; }
		
		[Field ("SCNLightAttenuationEndKey")]
		NSString AttenuationEndKey { get; }
		
		[Field ("SCNLightAttenuationFalloffExponentKey")]
		NSString AttenuationFalloffExponentKey { get; }
		
		[Field ("SCNLightSpotInnerAngleKey")]
		NSString SpotInnerAngleKey { get; }
		
		[Field ("SCNLightSpotOuterAngleKey")]
		NSString SpotOuterAngleKey { get; }
		
		[Field ("SCNLightShadowNearClippingKey")]
		NSString ShadowNearClippingKey { get; }
		
		[Field ("SCNLightShadowFarClippingKey")]
		NSString ShadowFarClippingKey { get; }
	}
#endif

	[Watch (3,0)]
	[iOS (8,0)]
	[Static]
	interface SCNLightingModel {
		[Field ("SCNLightingModelPhong")]
		NSString Phong { get; }
		
		[Field ("SCNLightingModelBlinn")]
		NSString Blinn { get; }
		
		[Field ("SCNLightingModelLambert")]
		NSString Lambert { get; }
		
		[Field ("SCNLightingModelConstant")]
		NSString Constant { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Field ("SCNLightingModelPhysicallyBased")]
		NSString PhysicallyBased { get; }
	}
	
	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNMaterial : SCNAnimatable, SCNShadable, NSCopying, NSSecureCoding {
		[NullAllowed] // by default this property is null
		[Export ("name", ArgumentSemantic.Copy)]
		string Name { get; set;  }

		[Export ("diffuse")]
		SCNMaterialProperty Diffuse { get;  }

		[Export ("ambient")]
		SCNMaterialProperty Ambient { get;  }

		[Export ("specular")]
		SCNMaterialProperty Specular { get;  }

		[Export ("emission")]
		SCNMaterialProperty Emission { get;  }

		[Export ("transparent")]
		SCNMaterialProperty Transparent { get;  }

		[Export ("reflective")]
		SCNMaterialProperty Reflective { get;  }

		[Export ("multiply")]
		SCNMaterialProperty Multiply { get;  }

		[Export ("normal")]
		SCNMaterialProperty Normal { get;  }

		[Export ("shininess")]
		nfloat Shininess { get; set;  }

		[Export ("transparency")]
		nfloat Transparency { get; set;  }

		[Export ("lightingModelName", ArgumentSemantic.Copy)]
		NSString LightingModelName { get; set;  }

		[Export ("litPerPixel")]
		bool LitPerPixel { [Bind ("isLitPerPixel")] get; set;  }

		[Export ("doubleSided")]
		bool DoubleSided { [Bind ("isDoubleSided")] get; set;  }

		[Export ("cullMode")]
		SCNCullMode CullMode { get; set;  }

		[Export ("transparencyMode")]
		SCNTransparencyMode TransparencyMode { get; set;  }

		[Export ("locksAmbientWithDiffuse")]
		bool LocksAmbientWithDiffuse { get; set;  }

		[Export ("writesToDepthBuffer")]
		bool WritesToDepthBuffer { get; set;  }

		[Static, Export ("material")]
		SCNMaterial Create ();

		[Mac (10,9)]
		[Export ("readsFromDepthBuffer")]
		bool ReadsFromDepthBuffer  { get; set; }

		[Mac (10,9)]
		[Export ("fresnelExponent")]
		nfloat FresnelExponent { get; set; }

		[iOS (9,0), Mac(10,11)]
		[Export ("blendMode", ArgumentSemantic.Assign)]
		SCNBlendMode BlendMode { get; set; }

		[iOS (9,0), Mac(10,11)]
		[Export ("ambientOcclusion")]
		SCNMaterialProperty AmbientOcclusion { get; }

		[iOS (9,0), Mac(10,11)]
		[Export ("selfIllumination")]
		SCNMaterialProperty SelfIllumination { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("metalness")]
		SCNMaterialProperty Metalness { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("roughness")]
		SCNMaterialProperty Roughness { get; }

#if XAMCORE_2_0
		[NoWatch]
		[iOS (9,0), Mac(10,11)]
		[Static]
		[Export ("materialWithMDLMaterial:")]
		SCNMaterial FromMaterial (MDLMaterial material);

		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("displacement")]
		SCNMaterialProperty Displacement { get; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("fillMode", ArgumentSemantic.Assign)]
		SCNFillMode FillMode { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("colorBufferWriteMask", ArgumentSemantic.Assign)]
		SCNColorMask ColorBufferWriteMask { get; set; }

#endif
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor] // runtime -> [SCNKit ERROR] Do not instantiate SCNMaterialProperty objects directly
	interface SCNMaterialProperty : SCNAnimatable, NSSecureCoding {
		[Export ("minificationFilter")]
		SCNFilterMode MinificationFilter { get; set;  }

		[Export ("magnificationFilter")]
		SCNFilterMode MagnificationFilter { get; set;  }

		[Export ("mipFilter")]
		SCNFilterMode MipFilter { get; set;  }

		[Export ("contentsTransform")]
		SCNMatrix4 ContentsTransform { get; set;  }

		[Export ("wrapS")]
		SCNWrapMode WrapS { get; set;  }

		[Export ("wrapT")]
		SCNWrapMode WrapT { get; set;  }

		[Deprecated (PlatformName.iOS, 10, 0)]
		[Deprecated (PlatformName.MacOSX, 10, 12)]
		[NoWatch, NoTV]
		[NullAllowed, Export ("borderColor", ArgumentSemantic.Retain)]
		NSObject BorderColor { get; set; }

		[Export ("mappingChannel")]
		nint MappingChannel { get; set;  }

		[Export ("contents", ArgumentSemantic.Retain), NullAllowed]
		NSObject Contents { get; set; }

		[Wrap ("Contents")]
		NSColor ContentColor { get; set; }

		[Wrap ("Contents")]
		NSImage ContentImage { get; set; }

		[NoWatch]
		[Wrap ("Contents")]
		CALayer ContentLayer { get; set; }

		[Wrap ("Contents")]
		NSString ContentPath { get; set; }

		[Wrap ("Contents")]
		NSUrl ContentUrl { get; set; }

#if XAMCORE_2_0 || !MONOMAC
		[Wrap ("Contents")]
		SKScene ContentScene { get; set; }

		[Wrap ("Contents")]
		SKTexture ContentTexture { get; set; }
#endif

		[Wrap ("Contents")]
		NSImage [] ContentImageCube { get; set; }

		[Mac (10,9)]
		[Export ("intensity")]
		nfloat Intensity { get; set; }

		[Mac (10,9)]
		[Export ("maxAnisotropy")]
		nfloat MaxAnisotropy { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("textureComponents", ArgumentSemantic.Assign)]
		SCNColorMask TextureComponents { get; set; }

		[Mac (10,9)]
		[Static, Export ("materialPropertyWithContents:")]
		SCNMaterialProperty Create (NSObject contents);
	}

#if !WATCH
	[NoWatch]
	[StrongDictionary ("SCNProgram")]
	interface SCNProgramSemanticOptions {
		nuint MappingChannel { get; set; }
	}
#endif

	[Watch (3,0)]
	[StrongDictionary ("SCNHitTest")]
	interface SCNHitTestOptions {
		bool FirstFoundOnly { get; set; }
		bool SortResults { get; set; }
		bool BackFaceCulling { get; set; }
		bool BoundingBoxOnly { get; set; }
		bool IgnoreChildNodes { get; set; }
		bool IgnoreHiddenNodes { get; set; }
		SCNNode RootNode { get; set; }
		SCNHitTestSearchMode SearchMode { get; set; }
	}

	[Watch (3,0)]
	[StrongDictionary ("SCNSceneSourceLoading")]
	interface SCNSceneLoadingOptions {
		NSUrl [] AssetDirectoryUrls { get; set; }
		bool CreateNormalsIfAbsent { get; set; }
		bool FlattenScene { get; set; }
		bool CheckConsistency { get; set; }
		bool OverrideAssetUrls { get; set; }
		bool StrictConformance { get; set; }
		bool UseSafeMode { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("SCNSceneSourceLoading.OptionPreserveOriginalTopology")]
		bool PreserveOriginalTopology { get; set; }

#if !TVOS && !WATCH
		// note: generator's StrongDictionary does not support No* attributes yet
		[NoTV]
		[NoWatch]
		float ConvertUnitsToMeters { get; set; } /* 'floating value encapsulated in a NSNumber' probably a float since it's a graphics framework */
		[NoTV]
		[NoWatch]
		bool ConvertToYUp { get; set; }
#endif

		[Internal, Export ("SCNSceneSourceLoading.AnimationImportPolicyKey")]
		NSString _AnimationImportPolicyKey { get; set; }
	}

	[iOS (8,0)]
	delegate bool SCNNodePredicate (SCNNode node, out bool stop);

	[iOS (8, 0)]
	delegate void SCNNodeHandler (SCNNode node, out bool stop);

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNNode : SCNAnimatable, SCNBoundingVolume, SCNActionable, NSCopying, NSSecureCoding 
#if IOS || TVOS
		, UIFocusItem
#endif
	{
		[Export ("transform")]
		SCNMatrix4 Transform { get; set;  }

		[Export ("position")]
		SCNVector3 Position { get; set;  }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("worldPosition", ArgumentSemantic.Assign)]
		SCNVector3 WorldPosition { get; set; }

		[Export ("rotation")]
		SCNVector4 Rotation { get; set;  }

		[Export ("scale")]
		SCNVector3 Scale { get; set;  }

		[Export ("pivot")]
		SCNMatrix4 Pivot { get; set;  }

		[Export ("worldTransform")]
		SCNMatrix4 WorldTransform { get; [Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)] set; }

		[Export ("hidden")]
		bool Hidden { [Bind ("isHidden")] get; set;  }

		[Export ("opacity")]
		nfloat Opacity { get; set;  }

		[Export ("renderingOrder")]
		nint RenderingOrder { get; set;  }

		[Export ("parentNode")]
		SCNNode ParentNode { get;  }

		[Export ("childNodes")]
		SCNNode [] ChildNodes { get;  }

		[Export ("light", ArgumentSemantic.Retain)]
		[NullAllowedAttribute]
		SCNLight Light { get; set; }

		[NullAllowed] // by default this property is null
		[Export ("camera", ArgumentSemantic.Retain)]
		SCNCamera Camera { get; set;  }

		[Export ("geometry", ArgumentSemantic.Retain)]
		SCNGeometry Geometry { get; [NullAllowed] set;  }

		[NullAllowed] // by default this property is null
		[Export ("name", ArgumentSemantic.Copy)]
		string Name { get; set;  }

		[NoWatch]
		[Export ("rendererDelegate", ArgumentSemantic.Assign), NullAllowed]
		NSObject WeakRendererDelegate { get; set;  }

		[NoWatch]
		[Wrap ("WeakRendererDelegate")]
		[Protocolize]
		SCNNodeRendererDelegate RendererDelegate { get; set; }

		[Static, Export ("node")]
		SCNNode Create ();

		[Static]
		[Export ("nodeWithGeometry:")]
		SCNNode FromGeometry ([NullAllowed] SCNGeometry geometry);

		[Export ("presentationNode")]
		SCNNode PresentationNode { get; }

		[Export ("insertChildNode:atIndex:")]
		void InsertChildNode (SCNNode child, nint index);

		[Export ("replaceChildNode:with:")]
		void ReplaceChildNode (SCNNode child, SCNNode child2);

		[Export ("removeFromParentNode")]
		void RemoveFromParentNode ();

		[Export ("addChildNode:")]
		void AddChildNode (SCNNode child);

		[Export ("childNodeWithName:recursively:")]
		SCNNode FindChildNode (string childName, bool recursively);

		[Export ("childNodesPassingTest:")]
		SCNNode [] FindNodes (SCNNodePredicate predicate);

		[Export ("clone")]
		SCNNode Clone ();

		[Mac (10,9)]
		[NullAllowed] // by default this property is null
		[Export ("skinner", ArgumentSemantic.Retain)]
		SCNSkinner Skinner { get; set; }

		[Mac (10,9)]
		[NullAllowed] // by default this property is null
		[Export ("morpher", ArgumentSemantic.Retain)]
		SCNMorpher Morpher { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("worldOrientation", ArgumentSemantic.Assign)]
		SCNQuaternion WorldOrientation { get; set; }

		[Mac (10,10)]
		[Export ("orientation")]
		SCNQuaternion Orientation { get; set; }

		[Mac (10,9)]
		[Export ("constraints", ArgumentSemantic.Copy)]
		SCNConstraint [] Constraints { get; [NullAllowed] set; }

		[NoWatch, Mac (10, 9)]
		[NullAllowed] // by default this property is null
		[Export ("filters", ArgumentSemantic.Copy)]
		CIFilter [] Filters { get; set; }

		[Mac (10,9)]
		[Export ("flattenedClone")]
		SCNNode FlattenedClone ();

		[Mac (10,9)]
		[Export ("convertPosition:toNode:")]
		SCNVector3 ConvertPositionToNode (SCNVector3 position, [NullAllowed] SCNNode node);

		[Mac (10,9)]
		[Export ("convertPosition:fromNode:")]
		SCNVector3 ConvertPositionFromNode (SCNVector3 position, [NullAllowed] SCNNode node);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("convertVector:toNode:")]
		SCNVector3 ConvertVectorToNode (SCNVector3 vector, [NullAllowed] SCNNode node);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("convertVector:fromNode:")]
		SCNVector3 ConvertVectorFromNode (SCNVector3 vector, [NullAllowed] SCNNode node);

		[Mac (10,9)]
		[Export ("convertTransform:fromNode:")]
		SCNMatrix4 ConvertTransformFromNode (SCNMatrix4 transform, [NullAllowed] SCNNode node);

		[Mac (10,9)]
		[Export ("convertTransform:toNode:")]
		SCNMatrix4 ConvertTransformToNode (SCNMatrix4 transform, [NullAllowed] SCNNode node);

		[Mac (10,9)]
		[Export ("hitTestWithSegmentFromPoint:toPoint:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNHitTestResult [] HitTest (SCNVector3 pointA, SCNVector3 pointB, [NullAllowed] NSDictionary options);

		[Wrap ("HitTest (pointA, pointB, options == null ? null : options.Dictionary)")]
		SCNHitTestResult [] HitTest (SCNVector3 pointA, SCNVector3 pointB, SCNHitTestOptions options);

		[Mac (10,10)]
		[Export ("eulerAngles")]
		SCNVector3 EulerAngles { get; set; }

		[Mac (10,10)]
		[Export ("castsShadow")]
		bool CastsShadow { get; set; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("movabilityHint", ArgumentSemantic.Assign)]
		SCNMovabilityHint MovabilityHint { get; set; }

		[Mac (10,10, onlyOn64 : true)] // More broken 32-bit code, 17710842
		[Export ("physicsBody", ArgumentSemantic.Retain), NullAllowed]
		SCNPhysicsBody PhysicsBody { get; set; }

		[Mac (10,10)]
		[NullAllowed] // by default this property is null
		[Export ("physicsField", ArgumentSemantic.Retain)]
		SCNPhysicsField PhysicsField { get; set; }

		[Mac (10,10)]
		[Export ("paused")]
		bool Paused { [Bind ("isPaused")] get; set; }

		[Mac (10,10)]
		[Export ("categoryBitMask")]
		nuint CategoryBitMask { get; set; }

		[Mac (10,10)]
		[Export ("enumerateChildNodesUsingBlock:")]
		void EnumerateChildNodes (SCNNodeHandler handler);

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("enumerateHierarchyUsingBlock:")]
		void EnumerateHierarchy (SCNNodeHandler handler);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("focusBehavior", ArgumentSemantic.Assign)]
		SCNNodeFocusBehavior FocusBehavior { get; set; }

		#region SCNParticleSystemSupport (SCNNode) category

		[Mac (10,10)]
		[Export ("particleSystems")]
		SCNParticleSystem [] ParticleSystems { get; }

		[Mac (10,10)]
		[Export ("addParticleSystem:")]
		void AddParticleSystem (SCNParticleSystem system);

		[Mac (10,10)]
		[Export ("removeAllParticleSystems")]
		void RemoveAllParticleSystems ();

		[Mac (10,10)]
		[Export ("removeParticleSystem:")]
		void RemoveParticleSystem (SCNParticleSystem system);

		#endregion

		#region SCNAudioSupport (SCNNode) category

		[iOS (9,0), Mac(10,11)]
		[Export ("audioPlayers")]
		SCNAudioPlayer [] AudioPlayers { get; }

		[iOS (9,0), Mac(10,11)]
		[Export ("addAudioPlayer:")]
		void AddAudioPlayer (SCNAudioPlayer player);

		[iOS (9,0), Mac(10,11)]
		[Export ("removeAllAudioPlayers")]
		void RemoveAllAudioPlayers ();

		[iOS (9,0), Mac(10,11)]
		[Export ("removeAudioPlayer:")]
		void RemoveAudioPlayer (SCNAudioPlayer player);

		#endregion

#if XAMCORE_2_0
		[NoWatch]
		[iOS (9,0), Mac(10,11)]
		[Static]
		[Export ("nodeWithMDLObject:")]
		SCNNode FromModelObject (MDLObject mdlObject);
#endif

		// From SCNNode (Transforms) Category

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Static]
		[Export ("localUp")]
		SCNVector3 LocalUp { get; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Static]
		[Export ("localRight")]
		SCNVector3 LocalRight { get; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Static]
		[Export ("localFront")]
		SCNVector3 LocalFront { get; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("worldUp")]
		SCNVector3 WorldUp { get; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("worldRight")]
		SCNVector3 WorldRight { get; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("worldFront")]
		SCNVector3 WorldFront { get; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("lookAt:")]
		void Look (SCNVector3 worldTarget);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("lookAt:up:localFront:")]
		void Look (SCNVector3 worldTarget, SCNVector3 worldUp, SCNVector3 localFront);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("localTranslateBy:")]
		void LocalTranslate (SCNVector3 translation);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("localRotateBy:")]
		void LocalRotate (SCNQuaternion rotation);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("rotateBy:aroundTarget:")]
		void Rotate (SCNQuaternion worldRotation, SCNVector3 worldTarget);

		// From SCNNode (SIMD) Category
		// Unfortunatelly had to prefix some props Simd due to the property name is already taken
		// by the SCN* version.

		// We took the decision to comment the following helpers since they currently do not bring
		// any benefits over the SCN* versions, actually the SIMD types could potentially be just
		// a little slower than the SCN* versions due to manual native conversion. If you really
		// need them please file a bug at https://github.com/xamarin/xamarin-macios/issues/new

		// Please add the following code to runtime/bindings-generator.cs if you reenable the following SIMD methods.

		/*
		 * Add to runtime/bindings-generator.cs
		 *

		data.Add (
				new FunctionData {
					Comment = " // void func (Quaternion, NVector3)",
					Prefix = "simd__",
					Variants = Variants.NonStret,
					Parameters = new ParameterData [] {
						new ParameterData { TypeData = Types.QuatF },
						new ParameterData { TypeData = Types.NVector3 }
					},
				}
			);

			data.Add (
				new FunctionData {
					Comment = " // void func (NVector3, NVector3, NVector3)",
					Prefix = "simd__",
					Variants = Variants.NonStret,
					Parameters = new ParameterData [] {
						new ParameterData { TypeData = Types.NVector3 },
						new ParameterData { TypeData = Types.NVector3 },
						new ParameterData { TypeData = Types.NVector3 }
					},
				}
			);

			data.Add (
				new FunctionData {
					Comment = " // NMatrix4 func (NMatrix4, IntPtr)",
					Prefix = "simd__",
					Variants = Variants.All,
					ReturnType = Types.NMatrix4,
					Parameters = new ParameterData [] {
						new ParameterData { TypeData = Types.NMatrix4 },
						new ParameterData { TypeData = Types.IntPtr }
					},
				}
			);

			data.Add (
				new FunctionData {
					Comment = " // NVector3 func (NVector3, IntPtr)",
					Prefix = "simd__",
					Variants = Variants.All,
					ReturnType = Types.NVector3,
					Parameters = new ParameterData [] {
						new ParameterData { TypeData = Types.NVector3 },
						new ParameterData { TypeData = Types.IntPtr }
					},
				}
			);

		 * End of bindings-generator.cs.
		 */

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdTransform", ArgumentSemantic.Assign)]
		//NMatrix4 SimdTransform {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdPosition", ArgumentSemantic.Assign)]
		//NVector3 SimdPosition {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdRotation", ArgumentSemantic.Assign)]
		//Vector4 SimdRotation {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdOrientation", ArgumentSemantic.Assign)]
		//Quaternion SimdOrientation {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdEulerAngles", ArgumentSemantic.Assign)]
		//NVector3 SimdEulerAngles {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdScale", ArgumentSemantic.Assign)]
		//NVector3 SimdScale {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdPivot", ArgumentSemantic.Assign)]
		//NMatrix4 SimdPivot {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdWorldPosition", ArgumentSemantic.Assign)]
		//NVector3 SimdWorldPosition {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdWorldOrientation", ArgumentSemantic.Assign)]
		//Quaternion SimdWorldOrientation {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdWorldTransform", ArgumentSemantic.Assign)]
		//NMatrix4 SimdWorldTransform {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	set;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdConvertPosition:toNode:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//NVector3 ConvertPositionToNode (NVector3 position, [NullAllowed] SCNNode node);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdConvertPosition:fromNode:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//NVector3 ConvertPositionFromNode (NVector3 position, [NullAllowed] SCNNode node);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdConvertVector:toNode:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//NVector3 ConvertVectorToNode (NVector3 vector, [NullAllowed] SCNNode node);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdConvertVector:fromNode:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//NVector3 ConvertVectorFromNode (NVector3 vector, [NullAllowed] SCNNode node);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdConvertTransform:toNode:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//NMatrix4 ConvertTransformToNode (NMatrix4 transform, [NullAllowed] SCNNode node);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdConvertTransform:fromNode:")]
		//NMatrix4 ConvertTransformFromNode (NMatrix4 transform, [NullAllowed] SCNNode node);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Static]
		//[Export ("simdLocalUp")]
		//NVector3 SimdLocalUp {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Static]
		//[Export ("simdLocalRight")]
		//NVector3 SimdLocalRight {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Static]
		//[Export ("simdLocalFront")]
		//NVector3 SimdLocalFront {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdWorldUp")]
		//NVector3 SimdWorldUp {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdWorldRight")]
		//NVector3 SimdWorldRight {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdWorldFront")]
		//NVector3 SimdWorldFront {
		//	[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//	get;
		//}

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdLookAt:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//void Look (NVector3 worldTarget);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdLookAt:up:localFront:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//void Look (NVector3 worldTarget, NVector3 worldUp, NVector3 localFront);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdLocalTranslateBy:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//void LocalTranslate (NVector3 translation);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdLocalRotateBy:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//void LocalRotate (Quaternion rotation);

		//[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		//[Export ("simdRotateBy:aroundTarget:")]
		//[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		//void Rotate (Quaternion worldRotation, NVector3 worldTarget);
	}

	[NoWatch]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[Model, Protocol]
	interface SCNNodeRendererDelegate {
		[Export ("renderNode:renderer:arguments:")]
		void Render (SCNNode node, SCNRenderer renderer, [NullAllowed] NSDictionary arguments);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	interface SCNPlane {
		[Export ("width")]
		nfloat Width { get; set;  }

		[Export ("height")]
		nfloat Height { get; set;  }

		[Export ("widthSegmentCount")]
		nint WidthSegmentCount { get; set;  }

		[Export ("heightSegmentCount")]
		nint HeightSegmentCount { get; set;  }

		[Static, Export ("planeWithWidth:height:")]
		SCNPlane Create (nfloat width, nfloat height);

		[Mac (10,9)]
		[Export ("cornerRadius")]
		nfloat CornerRadius { get; set; }

		[Mac (10,9)]
		[Export ("cornerSegmentCount")]
		nint CornerSegmentCount { get; set; }
	}

	delegate void SCNBufferBindingHandler (ISCNBufferStream buffer, SCNNode node, SCNShadable shadable, SCNRenderer renderer);

	[iOS (8,0), NoWatch]
	[BaseType (typeof (NSObject))]
	interface SCNProgram : NSCopying, NSSecureCoding {
		[NullAllowed]
		[Export ("vertexShader", ArgumentSemantic.Copy)]
		string VertexShader { get; set;  }

		[NullAllowed]
		[Export ("fragmentShader", ArgumentSemantic.Copy)]
		string FragmentShader { get; set;  }

		[iOS (9,0)][Mac (10,11)]
		[NullAllowed]
		[Export ("vertexFunctionName")]
		string VertexFunctionName { get; set; }

		[iOS (9,0)][Mac (10,11)]
		[NullAllowed]
		[Export ("fragmentFunctionName")]
		string FragmentFunctionName { get; set; }

		[iOS (9,0)][Mac (10,11)]
		[Export ("handleBindingOfBufferNamed:frequency:usingBlock:")]
		void HandleBinding (string name, SCNBufferFrequency frequency, SCNBufferBindingHandler handler);

		[Export ("delegate", ArgumentSemantic.Assign), NullAllowed]
		NSObject WeakDelegate { get; set;  }

		[Wrap ("WeakDelegate")]
		[Protocolize]
		SCNProgramDelegate Delegate { get; set; }

		[Static, Export ("program")]
		SCNProgram Create ();

		[Export ("setSemantic:forSymbol:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		void SetSemantic (NSString geometrySourceSemantic, string symbol, [NullAllowed] NSDictionary options);

#if !WATCH
		[NoWatch]
		[Wrap ("SetSemantic (geometrySourceSemantic, symbol, options == null ? null : options.Dictionary)")]
		void SetSemantic (NSString geometrySourceSemantic, string symbol, SCNProgramSemanticOptions options);
#endif

		[Export ("semanticForSymbol:")]
#if XAMCORE_4_0
		NSString GetSemantic (string symbol);
#else
		NSString GetSemanticForSymbol (string symbol);
#endif

		[NoWatch]
		[Field ("SCNProgramMappingChannelKey")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		NSString MappingChannelKey { get; }

		[Mac (10,10)]
		[Export ("opaque")]
		bool Opaque { [Bind ("isOpaque")] get; set; }

#if XAMCORE_2_0
		[NoWatch]
		[iOS (9,0)][Mac (10,11)]
		[NullAllowed]
		[Export ("library", ArgumentSemantic.Retain)]
		IMTLLibrary Library { get; set; }
#endif
	}

	[iOS (8,0), NoWatch]
	[BaseType (typeof (NSObject))]
	[Model, Protocol]
	interface SCNProgramDelegate {
#if MONOMAC || !XAMCORE_2_0
	#if XAMCORE_3_0
		[Availability (Unavailable = Platform.iOS_Version)]
	#endif
		[Availability (Deprecated = Platform.Mac_10_10)]
		[Export ("program:bindValueForSymbol:atLocation:programID:renderer:")]
		bool BindValue (SCNProgram program, string symbol, uint /* unsigned int */ location, uint /* unsigned int */ programID, SCNRenderer renderer);

	#if XAMCORE_3_0
		[Availability (Unavailable = Platform.iOS_Version)]
	#endif
		[Availability (Deprecated = Platform.Mac_10_10)]
		[Export ("program:unbindValueForSymbol:atLocation:programID:renderer:")]
		void UnbindValue (SCNProgram program, string symbol, uint /* unsigned int */ location, uint /* unsigned int */ programID, SCNRenderer renderer);
#endif

		[Export ("program:handleError:")]
		void HandleError (SCNProgram program, NSError error);

#if MONOMAC || !XAMCORE_2_0
	#if XAMCORE_3_0
		[Availability (Unavailable = Platform.iOS_Version)]
		[NoTV, NoWatch]
	#endif
		[Availability (Deprecated = Platform.Mac_10_10, Message = "Use the SCNProgram's Opaque property instead.")]
		[Export ("programIsOpaque:")]
		bool IsProgramOpaque (SCNProgram program);
#endif
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	interface SCNPyramid {
		[Export ("width")]
		nfloat Width { get; set;  }

		[Export ("height")]
		nfloat Height { get; set;  }

		[Export ("length")]
		nfloat Length { get; set;  }

		[Export ("widthSegmentCount")]
		nint WidthSegmentCount { get; set;  }

		[Export ("heightSegmentCount")]
		nint HeightSegmentCount { get; set;  }

		[Export ("lengthSegmentCount")]
		nint LengthSegmentCount { get; set;  }

		[Static, Export ("pyramidWithWidth:height:length:")]
		SCNPyramid Create (nfloat width, nfloat height, nfloat length);
	}

	[iOS (8,0), NoWatch]
	[BaseType (typeof (NSObject))]
#if !MONOMAC || XAMCORE_2_0
	[DisableDefaultCtor] // NSInvalidArgumentException Reason: -[SCNRenderer init]: unrecognized selector sent to instance 0x7ce85a30
#endif
	interface SCNRenderer : SCNSceneRenderer, SCNTechniqueSupport {
//		We already pull in the Scene property from the SCNSceneRenderer protocol, no need to redefine it here.
//		[Export ("scene", ArgumentSemantic.Retain)]
//		SCNScene Scene { get; set;  }

		// options: nothing today, it is reserved for future use
		[Static, Export ("rendererWithContext:options:")]
		SCNRenderer FromContext (IntPtr context, [NullAllowed] NSDictionary options);

		[NoWatch]
		[Static]
		[Wrap ("FromContext (context.GetHandle (), options)")]
		// GetHandle will return IntPtr.Zero is context is null
		// GLContext == CGLContext on macOS and EAGLContext in iOS and tvOS (using on top of file)
		SCNRenderer FromContext (GLContext context, [NullAllowed] NSDictionary options);

		[NoWatch, NoTV]
		[Export ("render")]
		[Deprecated (PlatformName.MacOSX, 10, 11)]
		[Deprecated (PlatformName.iOS, 9, 0)]
		void Render ();

		[Mac (10,10)]
		[Export ("renderAtTime:")]
		void Render (double timeInSeconds);

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("snapshotAtTime:withSize:antialiasingMode:")]
		NSImage GetSnapshot (double time, CGSize size, SCNAntialiasingMode antialiasingMode);

		[Mac (10,10)]
		[Export ("nextFrameTime")]
		double NextFrameTimeInSeconds { get; }

#if XAMCORE_2_0 || !MONOMAC
		[NoWatch]
		[iOS (9,0)][Mac (10,11)]
		[Static]
		[Export ("rendererWithDevice:options:")]
		SCNRenderer FromDevice ([NullAllowed] IMTLDevice device, [NullAllowed] NSDictionary options);

		[NoWatch]
		[iOS (9,0)][Mac (10,11)]
		[Export ("renderAtTime:viewport:commandBuffer:passDescriptor:")]
		void Render (double timeInSeconds, CGRect viewport, IMTLCommandBuffer commandBuffer, MTLRenderPassDescriptor renderPassDescriptor);

		[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
		[Export ("renderWithViewport:commandBuffer:passDescriptor:")]
		void Render (CGRect viewport, IMTLCommandBuffer commandBuffer, MTLRenderPassDescriptor renderPassDescriptor);
#endif
		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("updateProbes:atTime:")]
		void Update (SCNNode [] lightProbes, double time);

		[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
		[Export ("updateAtTime:")]
		void Update (double time);
	
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[Static]
	interface SCNRenderingArguments {
		[Field ("SCNModelTransform")]
		NSString ModelTransform { get; }

		[Field ("SCNViewTransform")]
		NSString ViewTransform { get; }
		
		[Field ("SCNProjectionTransform")]
		NSString ProjectionTransform { get; }
		
		[Field ("SCNNormalTransform")]
		NSString NormalTransform { get; }
		
		[Field ("SCNModelViewTransform")]
		NSString ModelViewTransform { get; }
		
		[Field ("SCNModelViewProjectionTransform")]
		NSString ModelViewProjectionTransform { get; }
	}

	[Mac (10,9), iOS (8,0)]
	delegate void SCNSceneExportProgressHandler (float /* float, not CGFloat */ totalProgress, NSError error, out bool stop);

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNScene :
#if (XAMCORE_2_0 || !MONOMAC) && !WATCH
		GKSceneRootNodeType ,
#endif
		NSSecureCoding {

		[Static]
		[Export ("scene")]
		SCNScene Create ();

		[Export ("rootNode")]
		SCNNode RootNode { get; }

		[Export ("attributeForKey:")]
		NSObject GetAttribute (NSString key);

		[Export ("setAttribute:forKey:")]
		void SetAttribute (NSObject attribute, NSString key);

		[Static]
		[Export ("sceneWithURL:options:error:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNScene FromUrl (NSUrl url, [NullAllowed] NSDictionary options, out NSError error);

		[Static]
		[Wrap ("FromUrl (url, options == null ? null : options.Dictionary, out error)")]
		SCNScene FromUrl (NSUrl url, [NullAllowed] SCNSceneLoadingOptions options, out NSError error);

		

		[Mac (10,9), iOS (8,0)]
		[Field ("SCNSceneExportDestinationURL")]
		NSString ExportDestinationUrl { get; }

		[Mac (10,10, onlyOn64 : true), iOS (8,0)] // More 32-bit brokenness - 17710842
		[Export ("physicsWorld")]
		SCNPhysicsWorld PhysicsWorld { get; }

		[Mac (10,9), iOS (8,0)]
		[Export ("background")]
		SCNMaterialProperty Background { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Export ("lightingEnvironment")]
		SCNMaterialProperty LightingEnvironment { get; }

		[Mac (10,10), iOS (8,0)]
		[Export ("fogStartDistance")]
		nfloat FogStartDistance { get; set; }

		[Mac (10,10), iOS (8,0)]
		[Export ("fogEndDistance")]
		nfloat FogEndDistance { get; set; }

		[Mac (10,10), iOS (8,0)]
		[Export ("fogDensityExponent")]
		nfloat FogDensityExponent { get; set; }

		[Mac (10,10), iOS (8,0)]
		[Export ("fogColor", ArgumentSemantic.Retain)]
		NSObject FogColor { get; set; }

		[Mac (10,10), iOS (8,0)]
		[Export ("paused")]
		bool Paused { [Bind ("isPaused")] get; set; }

		[Mac (10,9), iOS (8,0)]
		[Static, Export ("sceneNamed:")]
		SCNScene FromFile (string name);

		[Mac (10,10), iOS (8,0)]
		[Static, Export ("sceneNamed:inDirectory:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNScene FromFile (string name, [NullAllowed] string directory, [NullAllowed] NSDictionary options);

		[Mac (10,10), iOS (8,0)]
		[Static, Wrap ("FromFile (name, directory, options == null ? null : options.Dictionary)")]
		SCNScene FromFile (string name, string directory, SCNSceneLoadingOptions options);

		// Keeping here the same name WriteToUrl for iOS and friends because it is how it was bound
		// initialy for macOS and having it named diferently would hurt shared code
		[TV (10, 0), NoWatch, Mac (10, 9), iOS (10, 0)]
		[Export ("writeToURL:options:delegate:progressHandler:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		bool WriteToUrl (NSUrl url,
			[NullAllowed] NSDictionary options,
			[NullAllowed] ISCNSceneExportDelegate aDelegate,
			[NullAllowed] SCNSceneExportProgressHandler exportProgressHandler);

		[TV (10, 0), NoWatch, Mac (10, 9), iOS (10, 0)]
		[Wrap ("WriteToUrl (url, options == null ? null : options.Dictionary, handler, exportProgressHandler)")]
		bool WriteToUrl (NSUrl url, SCNSceneLoadingOptions options, ISCNSceneExportDelegate handler, SCNSceneExportProgressHandler exportProgressHandler);

		#region SCNParticleSystemSupport (SCNNode) category

		[Mac (10,10)]
		[Export ("particleSystems")]
		SCNParticleSystem [] ParticleSystems { get; }

		[Mac (10,10)]
		[Export ("addParticleSystem:withTransform:")]
		void AddParticleSystem (SCNParticleSystem system, SCNMatrix4 transform);

		[Mac (10,10)]
		[Export ("removeAllParticleSystems")]
		void RemoveAllParticleSystems ();

		[Mac (10,10)]
		[Export ("removeParticleSystem:")]
		void RemoveParticleSystem (SCNParticleSystem system);

		#endregion

		[Field ("SCNSceneStartTimeAttributeKey")]
		NSString StartTimeAttributeKey { get; }

		[Field ("SCNSceneEndTimeAttributeKey")]
		NSString EndTimeAttributeKey { get; }

		[Field ("SCNSceneFrameRateAttributeKey")]
		NSString FrameRateAttributeKey { get; }

		[iOS (8,0)][Mac (10,10)]
		[Field ("SCNSceneUpAxisAttributeKey")]
		NSString UpAxisAttributeKey { get; }

#if XAMCORE_2_0
		[NoWatch]
		[iOS (9,0), Mac(10,11)]
		[Static]
		[Export ("sceneWithMDLAsset:")]
		SCNScene FromAsset (MDLAsset asset);
#endif
	}

	interface ISCNSceneExportDelegate { }

	[TV (10, 0), NoWatch, Mac (10, 9), iOS (10, 0)]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface SCNSceneExportDelegate {

		[Export ("writeImage:withSceneDocumentURL:originalImageURL:")]
		[return: NullAllowed]
		NSUrl WriteImage (NSImage image, NSUrl documentUrl, [NullAllowed] NSUrl originalImageUrl);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNSceneSource {
		[Export ("url")]
		NSUrl Url { get;  }

		[Export ("data")]
		NSData Data { get;  }

		[Static, Export ("sceneSourceWithURL:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNSceneSource FromUrl (NSUrl url, [NullAllowed] NSDictionary options);

		[Wrap ("FromUrl (url, options == null ? null : options.Dictionary)")]
		SCNSceneSource FromUrl (NSUrl url, SCNSceneLoadingOptions options);

		[Static]
		[Export ("sceneSourceWithData:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNSceneSource FromData (NSData data, [NullAllowed] NSDictionary options);

		[Static]
		[Wrap ("FromData (data, options == null ? null : options.Dictionary)")]
		SCNSceneSource FromData (NSData data, SCNSceneLoadingOptions options);

		[Export ("initWithURL:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		IntPtr Constructor (NSUrl url, [NullAllowed] NSDictionary options);

		[Wrap ("this (url, options == null ? null : options.Dictionary)")]
		IntPtr Constructor (NSUrl url, SCNSceneLoadingOptions options);

		[Export ("initWithData:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		IntPtr Constructor (NSData data, [NullAllowed] NSDictionary options);

		[Wrap ("this (data, options == null ? null : options.Dictionary)")]
		IntPtr Constructor (NSData data, SCNSceneLoadingOptions options);
		
		[Export ("sceneWithOptions:statusHandler:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNScene SceneFromOptions ([NullAllowed] NSDictionary options, SCNSceneSourceStatusHandler statusHandler);

		[Wrap ("SceneFromOptions (options == null ? null : options.Dictionary, statusHandler)")]
		SCNScene SceneFromOptions (SCNSceneLoadingOptions options, SCNSceneSourceStatusHandler statusHandler);

		[Export ("sceneWithOptions:error:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNScene SceneWithOption ([NullAllowed] NSDictionary options, out NSError error);

		[Wrap ("SceneWithOption (options == null ? null : options.Dictionary, out error)")]
		SCNScene SceneWithOption (SCNSceneLoadingOptions options, out NSError error);

		[Export ("propertyForKey:")]
		NSObject GetProperty (NSString key);

		[Export ("entryWithIdentifier:withClass:")]
		NSObject GetEntryWithIdentifier (string uid, Class entryClass);

		[Export ("identifiersOfEntriesWithClass:")]
#if XAMCORE_2_0
		string [] GetIdentifiersOfEntries (Class entryClass);
#else
		NSObject [] IdentifiersOfEntriesWithClass (Class entryClass);
#endif

		[Mac (10,9)]
		[Export ("entriesPassingTest:")]
		NSObject [] EntriesPassingTest (SCNSceneSourceFilter predicate);		
	}
	delegate bool SCNSceneSourceFilter (NSObject entry, NSString identifier, ref bool stop);

	[Watch (3,0)]
	[iOS (8,0)]
	[Static]
	interface SCNSceneSourceLoading {
		[Field ("SCNSceneSourceAssetDirectoryURLsKey")]
		NSString AssetDirectoryUrlsKey { get; }
		
		[Field ("SCNSceneSourceCreateNormalsIfAbsentKey")]
		NSString CreateNormalsIfAbsentKey { get; }
		
		[Field ("SCNSceneSourceFlattenSceneKey")]
		NSString FlattenSceneKey { get; }
		
		[Field ("SCNSceneSourceCheckConsistencyKey")]
		NSString CheckConsistencyKey { get; }
		
		[Field ("SCNSceneSourceOverrideAssetURLsKey")]
		NSString OverrideAssetUrlsKey { get; }

		// Less preferred spelling, don't break stable API
		// note: was never released for XI
#if !XAMCORE_2_0 && MONOMAC
		[Obsolete ("Use AssetDirectoryUrlsKey")]
		[Field ("SCNSceneSourceAssetDirectoryURLsKey")]
		NSString AssetDirectoryURLsKey { get; }

		[Obsolete ("Use OverrideAssetUrlsKey")]
		[Field ("SCNSceneSourceOverrideAssetURLsKey")]
		NSString OverrideAssetURLsKey { get; }
#endif

		[Field ("SCNSceneSourceStrictConformanceKey")]
		NSString StrictConformanceKey { get; }
		
		[Deprecated (PlatformName.WatchOS, 4, 0)]
		[Deprecated (PlatformName.TvOS, 11, 0)]
		[Deprecated (PlatformName.iOS, 11, 0)]
		[Deprecated (PlatformName.MacOSX, 10, 13)]
		[Field ("SCNSceneSourceUseSafeModeKey")]
		NSString UseSafeModeKey	 { get; }

		[Mac(10,10)]
		[iOS (8,0)] // header said NA and docs says "Available in iOS 8.0 through iOS 8.2." but it's back on iOS11
		[TV (11,0), Watch (4,0)]
		[Field ("SCNSceneSourceConvertUnitsToMetersKey")]
		NSString ConvertUnitsToMetersKey { get; }

		[Mac(10,10)]
		[iOS (8,0)] // header said NA and docs says "Available in iOS 8.0 through iOS 8.2." but it's back on iOS11
		[TV (11,0), Watch (4,0)]
		[Field ("SCNSceneSourceConvertToYUpKey")]
		NSString ConvertToYUpKey { get; }

		[Mac(10,10), iOS(8,0)]
		[Field ("SCNSceneSourceAnimationImportPolicyKey")]
		NSString AnimationImportPolicyKey { get; }
		
		[Mac(10,10), iOS(8,0)]
		[Field ("SCNSceneSourceAnimationImportPolicyPlay")]
		NSString AnimationImportPolicyPlay { get; }
		
		[Mac(10,10), iOS(8,0)]
		[Field ("SCNSceneSourceAnimationImportPolicyPlayRepeatedly")]
		NSString AnimationImportPolicyPlayRepeatedly { get; }
		
		[Mac(10,10), iOS(8,0)]
		[Field ("SCNSceneSourceAnimationImportPolicyDoNotPlay")]
		NSString AnimationImportPolicyDoNotPlay { get; }
		
		[Mac(10,10), iOS(8,0)]
		[Field ("SCNSceneSourceAnimationImportPolicyPlayUsingSceneTimeBase")]
		NSString AnimationImportPolicyPlayUsingSceneTimeBase { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Field ("SCNSceneSourceLoadingOptionPreserveOriginalTopology")]
		NSString OptionPreserveOriginalTopology { get; }
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[Static]
	interface SCNSceneSourceLoadErrors {
		[Field ("SCNConsistencyElementIDErrorKey")]
		NSString ConsistencyElementIDErrorKey { get; }
		
		[Field ("SCNConsistencyElementTypeErrorKey")]
		NSString ConsistencyElementTypeErrorKey { get; }
		
		[Field ("SCNConsistencyLineNumberErrorKey")]
		NSString ConsistencyLineNumberErrorKey { get; }
		
		[Field ("SCNDetailedErrorsKey")]
		NSString DetailedErrorsKey { get; }
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[Static]
	interface SCNSceneSourceProperties {
		[Field ("SCNSceneSourceAssetContributorsKey")]
		NSString AssetContributorsKey { get; }
		
		[Field ("SCNSceneSourceAssetCreatedDateKey")]
		NSString AssetCreatedDateKey { get; }
		
		[Field ("SCNSceneSourceAssetModifiedDateKey")]
		NSString AssetModifiedDateKey { get; }
		
		[Field ("SCNSceneSourceAssetUpAxisKey")]
		NSString AssetUpAxisKey { get; }
		
		[Field ("SCNSceneSourceAssetUnitKey")]
		NSString AssetUnitKey { get; }

		[Field ("SCNSceneSourceAssetAuthoringToolKey")]
		NSString AssetAuthoringToolKey { get; }

		[Field ("SCNSceneSourceAssetAuthorKey")]
		NSString AssetAuthorKey { get; }

		[Field ("SCNSceneSourceAssetUnitNameKey")]
		NSString AssetUnitNameKey { get; }

		[Field ("SCNSceneSourceAssetUnitMeterKey")]
		NSString AssetUnitMeterKey { get; }
	}

	interface ISCNSceneRenderer {}

	[Watch (3,0)]
	[iOS (8,0)]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface SCNSceneRenderer {
#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("delegate", ArgumentSemantic.Weak), NullAllowed]
		NSObject WeakSceneRendererDelegate { get; set;  }

		[Wrap ("WeakSceneRendererDelegate")]
		[Protocolize]
		SCNSceneRendererDelegate SceneRendererDelegate { get; set; }

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("playing")]
		bool Playing { [Bind ("isPlaying")] get; set;  }

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("loops")]
		bool Loops { get; set;  }

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("pointOfView", ArgumentSemantic.Retain)]
		SCNNode PointOfView { get; set;  }

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("autoenablesDefaultLighting")]
		bool AutoenablesDefaultLighting { get; set;  }

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("jitteringEnabled")]
		bool JitteringEnabled { [Bind ("isJitteringEnabled")] get; set;  }

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("context")]
		IntPtr Context { get;  }

#if MONOMAC
		[Availability (Deprecated = Platform.Mac_10_10, Unavailable = Platform.iOS_Version)]
		[Export ("currentTime")]
		double CurrentTime { get; set; }
#endif

		[Abstract]
		[Export ("hitTest:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNHitTestResult [] HitTest (CGPoint thePoint, [NullAllowed] NSDictionary options);

		[Wrap ("HitTest (thePoint, options == null ? null : options.Dictionary)")]
		SCNHitTestResult [] HitTest (CGPoint thePoint, SCNHitTestOptions options);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Mac (10,9)]
		[Export ("showsStatistics")]
		bool ShowsStatistics { get; set; }

#if XAMCORE_2_0
		[Abstract]
#endif
		[Mac (10,10)]
		[Export ("sceneTime")]
		double SceneTimeInSeconds { get; set; }

#if XAMCORE_2_0
		[Abstract]
#endif
		[Mac (10,10)]
		[Export ("scene", ArgumentSemantic.Retain)]
		SCNScene Scene { get; set; }

#if XAMCORE_2_0
		[Abstract]
#endif
#if XAMCORE_2_0 || !MONOMAC
		// It seems swift has this property listed as an optional[0] and an Apple sample[1] sets this to null
		// [0]: https://developer.apple.com/documentation/scenekit/scnscenerenderer/1524051-overlayskscene
		// [1]: https://github.com/xamarin/xamarin-macios/issues/3392
		[NullAllowed]
		[Mac (10,10)]
		[Export ("overlaySKScene", ArgumentSemantic.Retain)]
		SKScene OverlayScene { get; set; }
#endif

#if XAMCORE_2_0
		[Abstract]
#endif
		[Mac (10,9)]
		[Export ("isNodeInsideFrustum:withPointOfView:")]
		bool IsNodeInsideFrustum (SCNNode node, SCNNode pointOfView);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Mac (10,9)]
		[Export ("projectPoint:")]
		SCNVector3 ProjectPoint (SCNVector3 point);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Mac (10,9)]
		[Export ("unprojectPoint:")]
		SCNVector3 UnprojectPoint (SCNVector3 point);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Mac (10,9)]
		[Export ("prepareObject:shouldAbortBlock:")]
		bool Prepare (NSObject obj, [NullAllowed] Func<bool> abortHandler);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Mac (10,10)]
		[Async]
		[Export ("prepareObjects:withCompletionHandler:")]
		void Prepare (NSObject [] objects, [NullAllowed] Action<bool> completionHandler);

#if XAMCORE_2_0 || !MONOMAC
	#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
	#endif
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)] // SKTransition -> SpriteKit -> only on 64 bits
		[Async]
		[Export ("presentScene:withTransition:incomingPointOfView:completionHandler:")]
		void PresentScene (SCNScene scene, SKTransition transition, [NullAllowed] SCNNode pointOfView, [NullAllowed] Action completionHandler);
#endif

#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
#endif
		[iOS (9,0)][Mac (10,11)]
		[Export ("nodesInsideFrustumWithPointOfView:")]
		SCNNode[] GetNodesInsideFrustum (SCNNode pointOfView);

#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
#endif
		[iOS (9,0)][Mac (10,11)]
		[Export ("debugOptions", ArgumentSemantic.Assign)]
		SCNDebugOptions DebugOptions { get; set; }

#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
#endif
		[iOS (9,0)][Mac (10,11)]
		[Export ("renderingAPI")]
		SCNRenderingApi RenderingApi { get; }

		// MonoMac / XM Classic does not have 64bits frameworks, e.g. Metal, and can't have those API
#if XAMCORE_2_0 || !MONOMAC
	#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
	#endif
		[NoWatch]
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)] // IMTLRenderCommandEncoder -> Metal -> only on 64 bits
		[NullAllowed, Export ("currentRenderCommandEncoder")]
		IMTLRenderCommandEncoder CurrentRenderCommandEncoder { get; }

	#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
	#endif
		[NoWatch]
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)]
		[NullAllowed, Export ("device")]
		IMTLDevice Device { get; }

	#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
	#endif
		[NoWatch]
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)]
		[Export ("colorPixelFormat")]
		MTLPixelFormat ColorPixelFormat { get; }

	#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
	#endif
		[NoWatch]
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)]
		[Export ("depthPixelFormat")]
		MTLPixelFormat DepthPixelFormat { get; }

	#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
	#endif
		[NoWatch]
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)]
		[Export ("stencilPixelFormat")]
		MTLPixelFormat StencilPixelFormat { get; }

	#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
	#endif
		[NoWatch]
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)]
		[NullAllowed, Export ("commandQueue")]
		IMTLCommandQueue CommandQueue { get; }
#endif

#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
#endif
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)]
		[Export ("audioEngine")]
		AVAudioEngine AudioEngine { get; }

#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
#endif
		[NoWatch]
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)]
		[Export ("audioEnvironmentNode")]
		[DebuggerBrowsable (DebuggerBrowsableState.Never)]
		AVAudioEnvironmentNode AudioEnvironmentNode { get; }

#if XAMCORE_4_0
		[Abstract] // this protocol existed before iOS 9 (or OSX 10.11) and we cannot add abstract members to it (breaking changes)
#endif
		[iOS (9,0)][Mac (10,11, onlyOn64 : true)]
		[NullAllowed, Export ("audioListener", ArgumentSemantic.Retain)]
		[DebuggerBrowsable (DebuggerBrowsableState.Never)]
		SCNNode AudioListener { get; set; }
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface SCNSceneRendererDelegate {

		[Export ("renderer:willRenderScene:atTime:")]
		void WillRenderScene ([Protocolize]SCNSceneRenderer renderer, SCNScene scene, double timeInSeconds);

		[Export ("renderer:didRenderScene:atTime:")]
		void DidRenderScene ([Protocolize]SCNSceneRenderer renderer, SCNScene scene, double timeInSeconds);

		[Mac (10,10)]
		[Export ("renderer:updateAtTime:")]
		void Update ([Protocolize]SCNSceneRenderer renderer, double timeInSeconds);

		[Mac (10,10)]
		[Export ("renderer:didApplyAnimationsAtTime:")]
		void DidApplyAnimations ([Protocolize]SCNSceneRenderer renderer, double timeInSeconds);

		[Mac (10,10)]
		[Export ("renderer:didSimulatePhysicsAtTime:")]
		void DidSimulatePhysics ([Protocolize]SCNSceneRenderer renderer, double timeInSeconds);

		[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
		[Export ("renderer:didApplyConstraintsAtTime:")]
		void DidApplyConstraints ([Protocolize] SCNSceneRenderer renderer, double atTime);
		
	}	

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	[DisableDefaultCtor] 
	interface SCNSphere {
		[Export ("radius")]
		nfloat Radius { get; set;  }

		[Export ("geodesic")]
		bool Geodesic { [Bind ("isGeodesic")] get; set;  }

		[Export ("segmentCount")]
		nint SegmentCount { get; set;  }

		[Static, Export ("sphereWithRadius:")]
		SCNSphere Create (nfloat radius);

	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	[DisableDefaultCtor] 
	interface SCNText {
		[Export ("extrusionDepth")]
		nfloat ExtrusionDepth { get; set;  }

		[Export ("string", ArgumentSemantic.Copy)]
		NSObject String { get; set;  }

		[Export ("containerFrame")]
		CGRect ContainerFrame { get; set;  }

#if MONOMAC
		// removed in iOS8 beta 5 - but it was already existing in 10.8 ?
		[Export ("textSize")]
		CGSize TextSize { get;  }
#endif

		[Export ("truncationMode", ArgumentSemantic.Copy)]
		string TruncationMode { get; set;  }

		[Export ("alignmentMode", ArgumentSemantic.Copy)]
		string AlignmentMode { get; set;  }

		[Export ("chamferRadius")]
		nfloat ChamferRadius { get; set;  }

#if MONOMAC && !XAMCORE_2_0
		[Availability (Deprecated = Platform.Mac_10_9)]
		[Export ("chamferSegmentCount")]
		nint ChamferSegmentCount { get; set;  }
#endif

		[Static, Export ("textWithString:extrusionDepth:")]
		SCNText Create (NSObject str, nfloat extrusionDepth);

		[Export ("font", ArgumentSemantic.Retain)]
		NSFont Font { get; set; }

		[Export ("wrapped")]
		bool Wrapped { [Bind ("isWrapped")] get; set; }

		[Mac (10,9)]
		[Export ("chamferProfile", ArgumentSemantic.Copy)]
		NSBezierPath ChamferProfile { get; set; }

		[Mac (10,9)]
		[Export ("flatness")]
		nfloat Flatness { get; set; }
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	[DisableDefaultCtor] 
	interface SCNTorus {
		[Export ("ringRadius")]
		nfloat RingRadius { get; set;  }

		[Export ("pipeRadius")]
		nfloat PipeRadius { get; set;  }

		[Export ("ringSegmentCount")]
		nint RingSegmentCount { get; set;  }

		[Export ("pipeSegmentCount")]
		nint PipeSegmentCount { get; set;  }

		[Static, Export ("torusWithRingRadius:pipeRadius:")]
		SCNTorus Create (nfloat ringRadius, nfloat pipeRadius);
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNTransaction {
		[Static]
		[Export ("begin")]
		void Begin ();

		[Static]
		[Export ("commit")]
		void Commit ();

		[Static]
		[Export ("flush")]
		void Flush ();

		[Static]
		[Export ("lock")]
		void Lock ();

		[Static]
		[Export ("unlock")]
		void Unlock ();

		[Static]
		[Export ("setCompletionBlock:")]
		void SetCompletionBlock ([NullAllowed] Action completion);

		[Export ("valueForKey:")]
		NSObject ValueForKey (NSString key);

		[Static]
		[Export ("setValue:forKey:")]
		void SetValueForKey (NSObject value, NSString key);

		//Detected properties
		[Static]
		[Export ("animationDuration")]
		double AnimationDuration { get; set; }

		[Static]
		[NoWatch]
		[NullAllowed] // by default this property is null
		[Export ("animationTimingFunction")]
		CAMediaTimingFunction AnimationTimingFunction { get; set; }

		[Static]
		[Export ("disableActions")]
		bool DisableActions { get; set; }
	}

	[Watch (3,0)]
	[iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	interface SCNTube {
		[Export ("innerRadius")]
		nfloat InnerRadius { get; set;  }

		[Export ("outerRadius")]
		nfloat OuterRadius { get; set;  }

		[Export ("height")]
		nfloat Height { get; set;  }

		[Export ("radialSegmentCount")]
		nint RadialSegmentCount { get; set;  }

		[Export ("heightSegmentCount")]
		nint HeightSegmentCount { get; set;  }

		[Static, Export ("tubeWithInnerRadius:outerRadius:height:")]
		SCNTube Create (nfloat innerRadius, nfloat outerRadius, nfloat height);
	}

	[NoWatch]
	[iOS (9,0)][Mac (10,11)]
	[Static]
	[Internal] // we'll make it public if there's a need for them (beside the strong dictionary we provide)
	interface SCNRenderingOptionsKeys {

		[Field ("SCNPreferredRenderingAPIKey")]
		NSString RenderingApiKey { get; }

		[Field ("SCNPreferredDeviceKey")]
		NSString DeviceKey { get; }

		[Field ("SCNPreferLowPowerDeviceKey")]
		NSString LowPowerDeviceKey { get; }
	}

#if !WATCH
	[NoWatch]
	[iOS (9,0)][Mac (10,11)]
	[StrongDictionary ("SCNRenderingOptionsKeys")]
	interface SCNRenderingOptions
	{

#if XAMCORE_2_0 || !MONOMAC
		IMTLDevice Device { get; set; }
#endif

		bool LowPowerDevice { get; set; }
	}
#endif

	[iOS (8,0), NoWatch]
	[BaseType (typeof (NSView))]
	[DisableDefaultCtor] 
	interface SCNView : SCNSceneRenderer, SCNTechniqueSupport {
//		We already pull in the Scene property from the SCNSceneRenderer protocol, no need to redefine it here.
//		[Export ("scene", ArgumentSemantic.Retain)]
//		SCNScene Scene { get; set;  }

#if MONOMAC
		[Export ("backgroundColor", ArgumentSemantic.Copy)]
		NSColor BackgroundColor { get; set;  }
#endif

		[Export ("allowsCameraControl")]
		bool AllowsCameraControl { get; set;  }

#if MONOMAC
		[Export ("openGLContext", ArgumentSemantic.Retain)]
		NSOpenGLContext	OpenGLContext { get; set;  }

		[Export ("pixelFormat", ArgumentSemantic.Retain)]
		NSOpenGLPixelFormat PixelFormat { get; set;  }
#elif !WATCH
		[Export ("eaglContext", ArgumentSemantic.Retain)]
#if XAMCORE_2_0
		EAGLContext EAGLContext { get; set; }
#else
		new EAGLContext Context { get; set; }
#endif
#endif

#if !WATCH
		[iOS (9,0)][Mac (10,11)]
		[Wrap ("this (frame, options != null ? options.Dictionary : null)")]
		IntPtr Constructor (CGRect frame, [NullAllowed] SCNRenderingOptions options);
#endif

		[Export ("initWithFrame:options:")]
		IntPtr Constructor (CGRect frame, [NullAllowed] NSDictionary options);

		[Export ("initWithFrame:")]
		IntPtr Constructor (CGRect frame);

		[Export ("play:")]
		void Play ([NullAllowed] NSObject sender);

		[Export ("pause:")]
		void Pause ([NullAllowed] NSObject sender);

		[Export ("stop:")]
		void Stop ([NullAllowed] NSObject sender);

		[iOS (8,0)][Mac (10,10)]
		[Export ("snapshot")]
		NSImage Snapshot ();

		[Mac (10,12)]
		[Export ("preferredFramesPerSecond")]
		nint PreferredFramesPerSecond { get; set; }

		[iOS (8,0)][Mac (10,10)]
		[Export ("antialiasingMode")]
		SCNAntialiasingMode AntialiasingMode { get; set; }

#if XAMCORE_2_0
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("cameraControlConfiguration")]
		ISCNCameraControlConfiguration CameraControlConfiguration { get; }

		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("defaultCameraController")]
		SCNCameraController DefaultCameraController { get; }
#endif
		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("rendersContinuously")]
		bool RendersContinuously { get; set; }
	}

#if XAMCORE_4_0
	[Mac (10,9), iOS (8,0), Watch (4,0)]
	delegate void SCNAnimationEventHandler (AnimationType animation, NSObject animatedObject, bool playingBackward);
#endif

	[Watch (4,0)]
	[Mac (10,9), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNAnimationEvent {

#if XAMCORE_4_0
		[Static, Export ("animationEventWithKeyTime:block:")]
		SCNAnimationEvent Create (nfloat keyTime, SCNAnimationEventHandler eventHandler);
#else
		[Internal]
		[Static, Export ("animationEventWithKeyTime:block:")]
		SCNAnimationEvent Create (nfloat keyTime, Action<IntPtr, NSObject, bool> handler);
#endif
	}

	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[BaseType (typeof (SCNGeometry))]
	partial interface SCNShape {
		[NullAllowed] // by default this property is null
		[Export ("path", ArgumentSemantic.Copy)]
		NSBezierPath Path { get; set; }

		[Export ("extrusionDepth")]
		nfloat ExtrusionDepth { get; set; }

		[Export ("chamferMode")]
		SCNChamferMode ChamferMode { get; set; }

		[Export ("chamferRadius")]
		nfloat ChamferRadius { get; set; }

		[NullAllowed] // by default this property is null
		[Export ("chamferProfile", ArgumentSemantic.Copy)]
		NSBezierPath ChamferProfile { get; set; }

		[Static, Export ("shapeWithPath:extrusionDepth:")]
		SCNShape Create (NSBezierPath path, nfloat extrusionDepth);
	}

	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNMorpher : SCNAnimatable, NSSecureCoding {
		[NullAllowed] // by default this property is null
		[Export ("targets", ArgumentSemantic.Copy)]
		SCNGeometry [] Targets { get; set; }

		[Export ("calculationMode")]
		SCNMorpherCalculationMode CalculationMode { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("weights", ArgumentSemantic.Retain)]
		NSNumber [] Weights { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("unifiesNormals")]
		bool UnifiesNormals { get; set; }

		[Export ("setWeight:forTargetAtIndex:")]
		void SetWeight (nfloat weight, nuint targetIndex);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("setWeight:forTargetNamed:")]
		void SetWeight (nfloat weight, string targetName);

		[Export ("weightForTargetAtIndex:")]
		nfloat GetWeight (nuint targetIndex);

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("weightForTargetNamed:")]
		nfloat GetWeight (string targetName);
	}

	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNSkinner : NSSecureCoding {
		[Export ("skeleton", ArgumentSemantic.Retain)]
		SCNNode Skeleton { get; set; }

		[Export ("baseGeometry", ArgumentSemantic.Retain)]
		SCNGeometry BaseGeometry { get; set; }

		[Mac (10,10)]
		[Export ("baseGeometryBindTransform")]
		SCNMatrix4 BaseGeometryBindTransform { get; set; }

		[Mac (10,10)]
		[Internal, Export ("boneInverseBindTransforms")]
		NSArray _BoneInverseBindTransforms { get; }

		[Mac (10,10)]
		[Export ("bones")]
		SCNNode [] Bones { get; }

		[Mac (10,10)]
		[Export ("boneWeights")]
		SCNGeometrySource BoneWeights { get; }

		[Mac (10,10)]
		[Export ("boneIndices")]
		SCNGeometrySource BoneIndices { get; }

		[Mac (10,10)]
		[Static, Internal, Export ("skinnerWithBaseGeometry:bones:boneInverseBindTransforms:boneWeights:boneIndices:")]
		SCNSkinner _Create (SCNGeometry baseGeometry, SCNNode [] bones, NSArray boneInverseBindTransforms,
			SCNGeometrySource boneWeights, SCNGeometrySource boneIndices);
	}

	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[Abstract]
	[DisableDefaultCtor]
	interface SCNConstraint : SCNAnimatable, NSCopying, NSSecureCoding {
		[Mac (10,10)]
		[Export ("influenceFactor")]
		nfloat InfluenceFactor { get; set; }

		[Mac (10, 10), iOS (8,0)]
		[TV (11,0)][Watch (4,0)]
		[Export ("enabled")]
		bool Enabled { [Bind ("isEnabled")] get; set; }

		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("incremental")]
		bool Incremental { [Bind ("isIncremental")] get; set; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (SCNConstraint))]
	[DisableDefaultCtor]
	interface SCNIKConstraint {

		[Export ("chainRootNode")]
		SCNNode ChainRootNode { get; }

		[Export ("targetPosition")]
		SCNVector3 TargetPosition { get; set; }

		[Static, Export ("inverseKinematicsConstraintWithChainRootNode:")]
		SCNIKConstraint Create (SCNNode chainRootNode);

		[Export ("setMaxAllowedRotationAngle:forJoint:")]
		void SetMaxAllowedRotationAnglet (nfloat angle, SCNNode node);

		[Export ("maxAllowedRotationAngleForJoint:")]
		nfloat GetMaxAllowedRotationAngle (SCNNode node);

		[iOS (9,0)][Mac (10,11)]
		[Export ("initWithChainRootNode:")]
		IntPtr Constructor (SCNNode chainRootNode);
		
	}

	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[BaseType (typeof (SCNConstraint))]
#if !MONOMAC || XAMCORE_2_0
	[DisableDefaultCtor]
#endif
	interface SCNLookAtConstraint {
		[Export ("target", ArgumentSemantic.Retain), NullAllowed]
		SCNNode Target { get; [Mac (10, 12), iOS (10, 0), TV (10, 0)] set; }

		[Export ("gimbalLockEnabled")]
		bool GimbalLockEnabled { get; set; }

		[Static, Export ("lookAtConstraintWithTarget:")]
		SCNLookAtConstraint Create ([NullAllowed] SCNNode target);

		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("targetOffset", ArgumentSemantic.Assign)]
		SCNVector3 TargetOffset { get; set; }
	
		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("localFront", ArgumentSemantic.Assign)]
		SCNVector3 LocalFront { get; set; }

		[Watch (4, 0), TV (11, 0), Mac (10, 13, onlyOn64: true), iOS (11, 0)]
		[Export ("worldUp", ArgumentSemantic.Assign)]
		SCNVector3 WorldUp { get; set; }
	}

	[Mac (10,9), iOS (8,0)]
	delegate SCNMatrix4 SCNTransformConstraintHandler (SCNNode node, SCNMatrix4 transform);

	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[BaseType (typeof (SCNConstraint))]
	[DisableDefaultCtor]
	interface SCNTransformConstraint {
		[Static, Export ("transformConstraintInWorldSpace:withBlock:")]
		SCNTransformConstraint Create (bool inWorldSpace, SCNTransformConstraintHandler transformHandler);

		[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
		[Static]
		[Export ("positionConstraintInWorldSpace:withBlock:")]
		SCNTransformConstraint CreatePositionConstraint (bool inWorldSpace, Func<SCNNode, SCNVector3, SCNVector3> transformHandler);
	
		[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
		[Static]
		[Export ("orientationConstraintInWorldSpace:withBlock:")]
		SCNTransformConstraint CreateOrientationConstraint (bool inWorldSpace, Func<SCNNode, SCNQuaternion, SCNQuaternion> transformHandler);
		
	}

	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNLevelOfDetail : NSCopying, NSSecureCoding {
		[Export ("geometry")]
		SCNGeometry Geometry { get; }

		[Export ("screenSpaceRadius")]
		nfloat ScreenSpaceRadius { get; }

		[Export ("worldSpaceDistance")]
		nfloat WorldSpaceDistance { get; }

		[Static, Export ("levelOfDetailWithGeometry:screenSpaceRadius:")]
		SCNLevelOfDetail CreateWithScreenSpaceRadius ([NullAllowed] SCNGeometry geometry, nfloat screenSpaceRadius);

		[Static, Export ("levelOfDetailWithGeometry:worldSpaceDistance:")]
		SCNLevelOfDetail CreateWithWorldSpaceDistance ([NullAllowed] SCNGeometry geometry, nfloat worldSpaceDistance);
	}

	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[Static]
	interface _SCNShaderModifiers {
		[Internal, Field ("SCNShaderModifierEntryPointGeometry")]
		NSString EntryPointGeometryKey { get; }

		[Internal, Field ("SCNShaderModifierEntryPointSurface")]
		NSString EntryPointSurfaceKey { get; }

		[Internal, Field ("SCNShaderModifierEntryPointLightingModel")]
		NSString EntryPointLightingModelKey { get; }

		[Internal, Field ("SCNShaderModifierEntryPointFragment")]
		NSString EntryPointFragmentKey { get; }
	}


	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface SCNActionable {
#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("runAction:")]
		void RunAction (SCNAction action);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("runAction:completionHandler:")]
		void RunAction (SCNAction action, [NullAllowed] Action block);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("runAction:forKey:")]
		void RunAction (SCNAction action, [NullAllowed] string key);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("runAction:forKey:completionHandler:")]
		void RunAction (SCNAction action, [NullAllowed] string key, [NullAllowed] Action block);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("hasActions")]
		bool HasActions ();

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("actionForKey:")]
		SCNAction GetAction (string key);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("removeActionForKey:")]
		void RemoveAction (string key);

#if XAMCORE_2_0
		[Abstract]
#endif
		[Export ("removeAllActions")]
		void RemoveAllActions ();

#if XAMCORE_4_0
		[Abstract]
#endif
		[iOS (8,0), Mac(10,10)]
		[Export ("actionKeys")]
		string [] ActionKeys { get; }
	}

	[Mac (10,10), iOS (8,0)]
	delegate void SCNActionNodeWithElapsedTimeHandler (SCNNode node, nfloat elapsedTime);

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	interface SCNAction : NSCopying, NSSecureCoding {

		[Export ("duration")]
		double DurationInSeconds { get; set; }

		[Export ("timingMode")]
		SCNActionTimingMode TimingMode { get; set; }

		[NullAllowed, Export ("timingFunction", ArgumentSemantic.Assign)]
#if XAMCORE_4_0
		Func<float,float> TimingFunction { get; set; }
#else
		Func<float,float> TimingFunction2 { get; set; }
#endif

		[Export ("speed")]
		nfloat Speed { get; set; }

		[Export ("reversedAction")]
		SCNAction ReversedAction ();

		[Static, Export ("moveByX:y:z:duration:")]
		SCNAction MoveBy (nfloat deltaX, nfloat deltaY, nfloat deltaZ, double durationInSeconds);

		[Static, Export ("moveBy:duration:")]
		SCNAction MoveBy (SCNVector3 delta, double durationInSeconds);

		[Static, Export ("moveTo:duration:")]
		SCNAction MoveTo (SCNVector3 location, double durationInSeconds);

		[Static, Export ("rotateByX:y:z:duration:")]
		SCNAction RotateBy (nfloat xAngle, nfloat yAngle, nfloat zAngle, double durationInSeconds);

		[Static, Export ("rotateByAngle:aroundAxis:duration:")]
		SCNAction RotateBy (nfloat angle, SCNVector3 axis, double durationInSeconds);

		[Static, Export ("rotateToX:y:z:duration:")]
		SCNAction RotateTo (nfloat xAngle, nfloat yAngle, nfloat zAngle, double durationInSeconds);

		[Static, Export ("rotateToX:y:z:duration:shortestUnitArc:")]
		SCNAction RotateTo (nfloat xAngle, nfloat yAngle, nfloat zAngle, double durationInSeconds, bool shortestUnitArc);

		[Static, Export ("rotateToAxisAngle:duration:")]
		SCNAction RotateTo (SCNVector4 axisAngle, double durationInSeconds);

		[Static, Export ("scaleBy:duration:")]
		SCNAction ScaleBy (nfloat scale, double durationInSeconds);

		[Static, Export ("scaleTo:duration:")]
		SCNAction ScaleTo (nfloat scale, double durationInSeconds);

		[Static, Export ("sequence:")]
		SCNAction Sequence (SCNAction [] actions);

		[Static, Export ("group:")]
		SCNAction Group (SCNAction [] actions);

		[Static, Export ("repeatAction:count:")]
		SCNAction RepeatAction (SCNAction action, nuint count);

		[Static, Export ("repeatActionForever:")]
		SCNAction RepeatActionForever (SCNAction action);

		[Static, Export ("fadeInWithDuration:")]
		SCNAction FadeIn (double durationInSeconds);

		[Static, Export ("fadeOutWithDuration:")]
		SCNAction FadeOut (double durationInSeconds);

		[Static, Export ("fadeOpacityBy:duration:")]
		SCNAction FadeOpacityBy (nfloat factor, double durationInSeconds);

		[Static, Export ("fadeOpacityTo:duration:")]
		SCNAction FadeOpacityTo (nfloat opacity, double durationInSeconds);

		[Static, Export ("waitForDuration:")]
		SCNAction Wait (double durationInSeconds);

		[Static, Export ("waitForDuration:withRange:")]
		SCNAction Wait (double durationInSeconds, double durationRange);

		[Static, Export ("removeFromParentNode")]
		SCNAction RemoveFromParentNode ();

		[Static, Export ("runBlock:")]
		SCNAction Run (Action<SCNNode> handler);

		[Static, Export ("runBlock:queue:")]
		SCNAction Run (Action<SCNNode> handler, DispatchQueue queue);

		[Static, Export ("javaScriptActionWithScript:duration:")]
		SCNAction FromJavascript (string script, double seconds);

		[Static, Export ("customActionWithDuration:actionBlock:")]
		SCNAction CustomAction (double seconds, SCNActionNodeWithElapsedTimeHandler handler);

		[Mac (10,11), iOS (9,0)]
		[Static, Export ("hide")]
		SCNAction Hide ();

		[Mac (10,11), iOS (9,0)]
		[Static, Export ("unhide")]
		SCNAction Unhide ();

		[Mac (10,11), iOS (9,0)]
		[Static, Export ("playAudioSource:waitForCompletion:")]
		SCNAction PlayAudioSource (SCNAudioSource source, bool wait);
	}

	[iOS (8,0)]
	delegate void SCNBindingHandler (uint /* unsigned int */ programId, uint /* unsigned int */ location, SCNNode renderedNode, SCNRenderer renderer);

	[Watch (3,0)]
	[StrongDictionary ("_SCNShaderModifiers")]
	interface SCNShaderModifiers {
		string EntryPointGeometry { get; set; }
		string EntryPointSurface { get; set; }
		string EntryPointLightingModel { get; set; }
		string EntryPointFragment { get; set; }
	}
	
	[Watch (3,0)]
	[Mac (10,9), iOS (8,0)]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface SCNShadable {

		[Mac (10,9, onlyOn64 : true)] // Not marked, but crashes 32-bit - 17695192
		[NullAllowed] // by default this property is null
		[Export ("shaderModifiers", ArgumentSemantic.Copy)]
		NSDictionary WeakShaderModifiers { get; set; }

		[Mac (10,9, onlyOn64 : true)] // Not marked, but crashes 32-bit - 17695192
		[Wrap ("WeakShaderModifiers")]
		SCNShaderModifiers ShaderModifiers { get; set; }

		[NoWatch]
		[NullAllowed] // by default this property is null
		[Export ("program", ArgumentSemantic.Retain)]
		SCNProgram Program { get; set; }

		[Mac (10,9), NoWatch]
		[Export ("handleBindingOfSymbol:usingBlock:")]
		void HandleBinding (string symbol, SCNBindingHandler handler);

		[Mac (10,9), NoWatch]
		[Export ("handleUnbindingOfSymbol:usingBlock:")]
		void HandleUnbinding (string symbol, SCNBindingHandler handler);
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNTechnique : SCNAnimatable, NSCopying, NSSecureCoding {

		[Export ("dictionaryRepresentation")]
#if XAMCORE_2_0
		NSDictionary ToDictionary ();
#else
		[Obsolete ("Use ToDictionary () instead")]
		NSDictionary DictionaryRepresentation { get; }
#endif

		[Static, Export ("techniqueWithDictionary:")]
		SCNTechnique Create (NSDictionary dictionary);

		[Static, Export ("techniqueBySequencingTechniques:")]
		SCNTechnique Create (SCNTechnique [] techniques);

		[NoWatch]
		[Export ("handleBindingOfSymbol:usingBlock:")]
		void HandleBinding (string symbol, [NullAllowed] SCNBindingHandler handler);

		[iOS (9,0)][Mac (10,11)]
		[Internal, Export ("objectForKeyedSubscript:")]
		[return: NullAllowed]
		NSObject _GetObject (NSObject key);

		[iOS (9,0)][Mac (10,11)]
		[Internal, Export ("setObject:forKeyedSubscript:")]
		void _SetObject ([NullAllowed] NSObject obj, INSCopying key);
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface SCNTechniqueSupport {
		[Abstract]
		[Mac (10,10), iOS (8,0)]
		[Export ("technique", ArgumentSemantic.Copy)]
		SCNTechnique Technique { get; [NullAllowed] set; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[Static]
	interface SCNPhysicsTestKeys {

		[Field ("SCNPhysicsTestCollisionBitMaskKey")]
		NSString CollisionBitMaskKey { get; }

		[Field ("SCNPhysicsTestSearchModeKey")]
		NSString SearchModeKey { get; }

		[Field ("SCNPhysicsTestBackfaceCullingKey")]
		NSString BackfaceCullingKey { get; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[Static]
	interface SCNPhysicsTestSearchModeKeys {

		[Field ("SCNPhysicsTestSearchModeAny")]
		NSString Any { get; }

		[Field ("SCNPhysicsTestSearchModeClosest")]
		NSString Closest { get; }

		[Field ("SCNPhysicsTestSearchModeAll")]
		NSString All { get; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNPhysicsBody : NSCopying, NSSecureCoding {

		[Static, Export ("staticBody")]
		SCNPhysicsBody CreateStaticBody ();

		[Static, Export ("dynamicBody")]
		SCNPhysicsBody CreateDynamicBody ();

		[Static, Export ("kinematicBody")]
		SCNPhysicsBody CreateKinematicBody ();

		[Static, Export ("bodyWithType:shape:")]
		SCNPhysicsBody CreateBody (SCNPhysicsBodyType type, [NullAllowed] SCNPhysicsShape shape);

		[Export ("type")]
		SCNPhysicsBodyType Type { get; set; }

		[Export ("mass")]
		nfloat Mass { get; set; }

		[Export ("friction")]
		nfloat Friction { get; set; }

		[Export ("charge")]
		nfloat Charge { get; set; }

		[Export ("restitution")]
		nfloat Restitution { get; set; }

		[Export ("rollingFriction")]
		nfloat RollingFriction { get; set; }

		[Export ("physicsShape", ArgumentSemantic.Retain)]
		SCNPhysicsShape PhysicsShape { get; set; }

		[Export ("isResting")]
		bool IsResting { get; }

		[Export ("allowsResting")]
		bool AllowsResting { get; set; }

		[Export ("velocity")]
		SCNVector3 Velocity { get; set; }

		[Export ("angularVelocity")]
		SCNVector4 AngularVelocity { get; set; }

		[Export ("damping")]
		nfloat Damping { get; set; }

		[Export ("angularDamping")]
		nfloat AngularDamping { get; set; }

		[Export ("velocityFactor")]
		SCNVector3 VelocityFactor { get; set; }

		[Export ("angularVelocityFactor")]
		SCNVector3 AngularVelocityFactor { get; set; }

		[Export ("categoryBitMask", ArgumentSemantic.UnsafeUnretained)]
		nuint CategoryBitMask { get; set; }

		[Export ("collisionBitMask", ArgumentSemantic.UnsafeUnretained)]
		nuint CollisionBitMask { get; set; }

		[Export ("applyForce:impulse:")]
		void ApplyForce (SCNVector3 direction, bool impulse);

		[Export ("applyForce:atPosition:impulse:")]
		void ApplyForce (SCNVector3 direction, SCNVector3 position, bool impulse);

		[Export ("applyTorque:impulse:")]
		void ApplyTorque (SCNVector4 torque, bool impulse);

		[Export ("clearAllForces")]
		void ClearAllForces ();

		[Export ("resetTransform")]
		void ResetTransform ();

		[iOS (9,0), Mac(10,11)]
		[Export ("momentOfInertia", ArgumentSemantic.Assign)]
		SCNVector3 MomentOfInertia { get; set; }

		[iOS (9,0), Mac(10,11)]
		[Export ("usesDefaultMomentOfInertia")]
		bool UsesDefaultMomentOfInertia { get; set; }

		[iOS (9,0), Mac(10,11)]
		[Export ("contactTestBitMask", ArgumentSemantic.Assign)]
		nuint ContactTestBitMask { get; set; }		

		[iOS (9,0), Mac(10,11)]
		[Export ("affectedByGravity")]
		bool AffectedByGravity { [Bind ("isAffectedByGravity")] get; set; }
		
		[Watch (5,0), TV (12,0), Mac (10,14, onlyOn64: true), iOS (12,0)]
		[Export ("setResting:")]
		void SetResting (bool resting);

		[Watch (5,0), TV (12,0), Mac (10,14, onlyOn64: true), iOS (12,0)]
		[Export ("continuousCollisionDetectionThreshold")]
		nfloat ContinuousCollisionDetectionThreshold { get; set; }

		[Watch (5,0), TV (12,0), Mac (10,14, onlyOn64: true), iOS (12,0)]
		[Export ("centerOfMassOffset", ArgumentSemantic.Assign)]
		SCNVector3 CenterOfMassOffset { get; set; }

		[Watch (5,0), TV (12,0), Mac (10,14, onlyOn64: true), iOS (12,0)]
		[Export ("linearRestingThreshold")]
		nfloat LinearRestingThreshold { get; set; }

		[Watch (5,0), TV (12,0), Mac (10,14, onlyOn64: true), iOS (12,0)]
		[Export ("angularRestingThreshold")]
		nfloat AngularRestingThreshold { get; set; }
	}

	[Mac (10,10), iOS (8,0)]
	delegate SCNVector3 SCNFieldForceEvaluator (SCNVector3 position, SCNVector3 velocity, float /* float, not CGFloat */ mass, float /* float, not CGFloat */ charge, double timeInSeconds);

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNPhysicsField : NSCopying, NSSecureCoding {

		[Static, Export ("dragField")]
		SCNPhysicsField CreateDragField ();

		[Static, Export ("vortexField")]
		SCNPhysicsField CreateVortexField ();

		[Static, Export ("radialGravityField")]
		SCNPhysicsField CreateRadialGravityField ();

		[Static, Export ("linearGravityField")]
		SCNPhysicsField CreateLinearGravityField ();

		[Static, Export ("noiseFieldWithSmoothness:animationSpeed:")]
		SCNPhysicsField CreateNoiseField (nfloat smoothness, nfloat speed);

		[Static, Export ("turbulenceFieldWithSmoothness:animationSpeed:")]
		SCNPhysicsField CreateTurbulenceField (nfloat smoothness, nfloat speed);

		[Static, Export ("springField")]
		SCNPhysicsField CreateSpringField ();

		[Static, Export ("electricField")]
		SCNPhysicsField CreateElectricField ();

		[Static, Export ("magneticField")]
		SCNPhysicsField CreateMagneticField ();

		[Static, Export ("customFieldWithEvaluationBlock:")]
		SCNPhysicsField CustomField (SCNFieldForceEvaluator evaluator);

		[Export ("strength")]
		nfloat Strength { get; set; }

		[Export ("falloffExponent")]
		nfloat FalloffExponent { get; set; }

		[Export ("minimumDistance")]
		nfloat MinimumDistance { get; set; }

		[Export ("active")]
		bool Active { [Bind ("isActive")] get; set; }

		[Export ("exclusive")]
		bool Exclusive { [Bind ("isExclusive")] get; set; }

		[Export ("halfExtent")]
		SCNVector3 HalfExtent { get; set; }

		[Export ("usesEllipsoidalExtent")]
		bool UsesEllipsoidalExtent { get; set; }

		[Export ("scope")]
		SCNPhysicsFieldScope Scope { get; set; }

		[Export ("offset")]
		SCNVector3 Offset { get; set; }

		[Export ("direction")]
		SCNVector3 Direction { get; set; }

		[Export ("categoryBitMask")]
		nuint CategoryBitMask { get; set; }
	}

	[Watch (3,0)]
	[StrongDictionary ("SCNPhysicsTestKeys")]
	interface SCNPhysicsTest {
		nuint CollisionBitMask { get; set; }

		bool BackfaceCulling { get; set; }

		[Internal, Export ("SCNPhysicsTestKeys.SearchModeKey")]
		NSString _SearchMode { get; set; }
	}
	
	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject),
		Delegates = new [] { "WeakContactDelegate" },
		Events = new [] { typeof (SCNPhysicsContactDelegate) }
	)]
	[DisableDefaultCtor] // not to be allocated directly; use SCNScene.PhysicsWorld
	interface SCNPhysicsWorld : NSSecureCoding {

		[Export ("gravity")]
		SCNVector3 Gravity { get; set; }

		[Export ("speed")]
		nfloat Speed { get; set; }

		[Export ("timeStep")]
		double TimeStep { get; set; }

		[Export ("contactDelegate", ArgumentSemantic.Weak)]
		[NullAllowed]
		NSObject WeakContactDelegate { get; set; }

		[Wrap ("WeakContactDelegate")]
		[Protocolize]
		SCNPhysicsContactDelegate ContactDelegate { get; set; }

		[Export ("addBehavior:")]
		void AddBehavior (SCNPhysicsBehavior behavior);

		[Export ("removeBehavior:")]
		void RemoveBehavior (SCNPhysicsBehavior behavior);

		[Export ("removeAllBehaviors")]
		void RemoveAllBehaviors ();

		[Export ("allBehaviors")]
		SCNPhysicsBehavior [] AllBehaviors { get; }

		[Export ("rayTestWithSegmentFromPoint:toPoint:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNHitTestResult [] RayTestWithSegmentFromPoint (SCNVector3 origin, SCNVector3 dest, [NullAllowed] NSDictionary options);

		[Wrap ("RayTestWithSegmentFromPoint (origin, dest, options != null ? options.Dictionary : null)")]
		SCNHitTestResult [] RayTestWithSegmentFromPoint (SCNVector3 origin, SCNVector3 dest, [NullAllowed] SCNPhysicsTest options);

		[Export ("contactTestBetweenBody:andBody:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNPhysicsContact [] ContactTest (SCNPhysicsBody bodyA, SCNPhysicsBody bodyB, [NullAllowed] NSDictionary options);

		[Wrap ("ContactTest (bodyA, bodyB, options != null ? options.Dictionary : null)")]
		SCNPhysicsContact [] ContactTest (SCNPhysicsBody bodyA, SCNPhysicsBody bodyB, [NullAllowed] SCNPhysicsTest options);

		[Export ("contactTestWithBody:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNPhysicsContact [] ContactTest (SCNPhysicsBody body, [NullAllowed] NSDictionary options);

		[Wrap ("ContactTest (body, options != null ? options.Dictionary : null)")]
		SCNPhysicsContact [] ContactTest (SCNPhysicsBody body, [NullAllowed] SCNPhysicsTest options);

		[Export ("convexSweepTestWithShape:fromTransform:toTransform:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNPhysicsContact [] ConvexSweepTest (SCNPhysicsShape shape, SCNMatrix4 from, SCNMatrix4 to, [NullAllowed] NSDictionary options);

		[Wrap ("ConvexSweepTest (shape, from, to, options != null ? options.Dictionary : null)")]
		SCNPhysicsContact [] ConvexSweepTest (SCNPhysicsShape shape, SCNMatrix4 from, SCNMatrix4 to, [NullAllowed] SCNPhysicsTest options);

		[Export ("updateCollisionPairs")]
		void UpdateCollisionPairs ();
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNPhysicsShape : NSCopying, NSSecureCoding {

		[Internal, Static, Export ("shapeWithShapes:transforms:")]
		SCNPhysicsShape Create (SCNPhysicsShape [] shapes, NSValue [] transforms);

		[Static, Export ("shapeWithGeometry:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNPhysicsShape Create (SCNGeometry geometry, [NullAllowed] NSDictionary options);

		[Static, Export ("shapeWithNode:options:")]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		SCNPhysicsShape Create (SCNNode node, [NullAllowed] NSDictionary options);

		[iOS (9,0), Mac(10,11)]
		[NullAllowed, Export ("options"), Internal]
		NSDictionary _Options { get; }

		[iOS (9,0), Mac(10,11)]
		[Export ("sourceObject")]
		NSObject SourceObject { get; }

		[iOS (9,0), Mac(10,11)]
		[NullAllowed, Export ("transforms")]
		NSValue[] Transforms { get; }		
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[Static]
	[EditorBrowsable (EditorBrowsableState.Advanced)]
	interface SCNPhysicsShapeOptionsKeys {

		[Field ("SCNPhysicsShapeScaleKey")]
		NSString Scale { get; }

		[TV (10, 0), Mac (10, 12), iOS (10, 0)]
		[Field ("SCNPhysicsShapeOptionCollisionMargin")]
		NSString CollisionMargin { get; }

		[Field ("SCNPhysicsShapeKeepAsCompoundKey")]
		NSString KeepAsCompound { get; }

		[Field ("SCNPhysicsShapeTypeKey")]
		NSString Type { get; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[Static]
	[EditorBrowsable (EditorBrowsableState.Advanced)]
	interface SCNPhysicsShapeOptionsTypes {

		[Field ("SCNPhysicsShapeTypeBoundingBox")]
		NSString BoundingBox { get; }

		[Field ("SCNPhysicsShapeTypeConvexHull")]
		NSString ConvexHull { get; }

		[Field ("SCNPhysicsShapeTypeConcavePolyhedron")]
		NSString ConcavePolyhedron { get; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNPhysicsContact {

		[Export ("nodeA")]
		SCNNode NodeA { get; }

		[Export ("nodeB")]
		SCNNode NodeB { get; }

		[Export ("contactPoint")]
		SCNVector3 ContactPoint { get; }

		[Export ("contactNormal")]
		SCNVector3 ContactNormal { get; }

		[Export ("collisionImpulse")]
		nfloat CollisionImpulse { get; }

		[Export ("penetrationDistance")]
		nfloat PenetrationDistance { get; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("sweepTestFraction")]
		nfloat SweepTestFraction { get; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface SCNPhysicsContactDelegate {

		[Export ("physicsWorld:didBeginContact:"), EventArgs ("SCNPhysicsContact")]
		void DidBeginContact (SCNPhysicsWorld world, SCNPhysicsContact contact);

		[Export ("physicsWorld:didUpdateContact:"), EventArgs ("SCNPhysicsContact")]
		void DidUpdateContact (SCNPhysicsWorld world, SCNPhysicsContact contact);

		[Export ("physicsWorld:didEndContact:"), EventArgs ("SCNPhysicsContact")]
		void DidEndContact (SCNPhysicsWorld world, SCNPhysicsContact contact);
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[Abstract]
	[DisableDefaultCtor]
	interface SCNPhysicsBehavior : NSSecureCoding {

	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (SCNPhysicsBehavior))]
	[DisableDefaultCtor]
	interface SCNPhysicsHingeJoint {

		[Static, Export ("jointWithBodyA:axisA:anchorA:bodyB:axisB:anchorB:")]
		SCNPhysicsHingeJoint Create (SCNPhysicsBody bodyA, SCNVector3 axisA, SCNVector3 anchorA,
			[NullAllowed] SCNPhysicsBody bodyB, SCNVector3 axisB, SCNVector3 anchorB);

		[Static, Export ("jointWithBody:axis:anchor:")]
		SCNPhysicsHingeJoint Create (SCNPhysicsBody body, SCNVector3 axis, SCNVector3 anchor);

		[Export ("bodyA")]
		SCNPhysicsBody BodyA { get; }

		[Export ("axisA")]
		SCNVector3 AxisA { get; set; }

		[Export ("anchorA")]
		SCNVector3 AnchorA { get; set; }

		[Export ("bodyB")]
		SCNPhysicsBody BodyB { get; }

		[Export ("axisB")]
		SCNVector3 AxisB { get; set; }

		[Export ("anchorB")]
		SCNVector3 AnchorB { get; set; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (SCNPhysicsBehavior))]
	[DisableDefaultCtor]
	interface SCNPhysicsBallSocketJoint {

		[Static, Export ("jointWithBodyA:anchorA:bodyB:anchorB:")]
		SCNPhysicsBallSocketJoint Create (SCNPhysicsBody bodyA, SCNVector3 anchorA, SCNPhysicsBody bodyB, SCNVector3 anchorB);

		[Static, Export ("jointWithBody:anchor:")]
		SCNPhysicsBallSocketJoint Create (SCNPhysicsBody body, SCNVector3 anchor);

		[Export ("bodyA")]
		SCNPhysicsBody BodyA { get; }

		[Export ("anchorA")]
		SCNVector3 AnchorA { get; set; }

		[Export ("bodyB")]
		SCNPhysicsBody BodyB { get; }

		[Export ("anchorB")]
		SCNVector3 AnchorB { get; set; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (SCNPhysicsBehavior))]
	[DisableDefaultCtor]
	interface SCNPhysicsSliderJoint {

		[Static, Export ("jointWithBodyA:axisA:anchorA:bodyB:axisB:anchorB:")]
		SCNPhysicsSliderJoint Create (SCNPhysicsBody bodyA, SCNVector3 axisA,
			SCNVector3 anchorA, SCNPhysicsBody bodyB, SCNVector3 axisB, SCNVector3 anchorB);

		[Static, Export ("jointWithBody:axis:anchor:")]
		SCNPhysicsSliderJoint Create (SCNPhysicsBody body, SCNVector3 axis, SCNVector3 anchor);

		[Export ("bodyA")]
		SCNPhysicsBody BodyA { get; }

		[Export ("axisA")]
		SCNVector3 AxisA { get; set; }

		[Export ("anchorA")]
		SCNVector3 AnchorA { get; set; }

		[Export ("bodyB")]
		SCNPhysicsBody BodyB { get; }

		[Export ("axisB")]
		SCNVector3 AxisB { get; set; }

		[Export ("anchorB")]
		SCNVector3 AnchorB { get; set; }

		[Export ("minimumLinearLimit")]
		nfloat MinimumLinearLimit { get; set; }

		[Export ("maximumLinearLimit")]
		nfloat MaximumLinearLimit { get; set; }

		[Export ("minimumAngularLimit")]
		nfloat MinimumAngularLimit { get; set; }

		[Export ("maximumAngularLimit")]
		nfloat MaximumAngularLimit { get; set; }

		[Export ("motorTargetLinearVelocity")]
		nfloat MotorTargetLinearVelocity { get; set; }

		[Export ("motorMaximumForce")]
		nfloat MotorMaximumForce { get; set; }

		[Export ("motorTargetAngularVelocity")]
		nfloat MotorTargetAngularVelocity { get; set; }

		[Export ("motorMaximumTorque")]
		nfloat MotorMaximumTorque { get; set; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (SCNPhysicsBehavior))]
	[DisableDefaultCtor]
	interface SCNPhysicsVehicle {

		[Static, Export ("vehicleWithChassisBody:wheels:")]
		SCNPhysicsVehicle Create (SCNPhysicsBody chassisBody, SCNPhysicsVehicleWheel [] wheels);

		[Export ("speedInKilometersPerHour")]
		nfloat SpeedInKilometersPerHour { get; }

		[Export ("wheels")]
		SCNPhysicsVehicleWheel [] Wheels { get; }

		[Export ("chassisBody")]
		SCNPhysicsBody ChassisBody { get; }

		[Export ("applyEngineForce:forWheelAtIndex:")]
		void ApplyEngineForce (nfloat value, nint index);

		[Export ("setSteeringAngle:forWheelAtIndex:")]
		void SetSteeringAngle (nfloat value, nint index);

		[Export ("applyBrakingForce:forWheelAtIndex:")]
		void ApplyBrakingForce (nfloat value, nint index);
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNPhysicsVehicleWheel : NSCopying, NSSecureCoding {

		[Static, Export ("wheelWithNode:")]
		SCNPhysicsVehicleWheel Create (SCNNode node);

		[Export ("node")]
		SCNNode Node { get; }

		[Export ("suspensionStiffness")]
		nfloat SuspensionStiffness { get; set; }

		[Export ("suspensionCompression")]
		nfloat SuspensionCompression { get; set; }

		[Export ("suspensionDamping")]
		nfloat SuspensionDamping { get; set; }

		[Export ("maximumSuspensionTravel")]
		nfloat MaximumSuspensionTravel { get; set; }

		[Export ("frictionSlip")]
		nfloat FrictionSlip { get; set; }

		[Export ("maximumSuspensionForce")]
		nfloat MaximumSuspensionForce { get; set; }

		[Export ("connectionPosition")]
		SCNVector3 ConnectionPosition { get; set; }

		[Export ("steeringAxis")]
		SCNVector3 SteeringAxis { get; set; }

		[Export ("axle")]
		SCNVector3 Axle { get; set; }

		[Export ("radius")]
		nfloat Radius { get; set; }

		[Export ("suspensionRestLength")]
		nfloat SuspensionRestLength { get; set; }
	}

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNParticleSystem : NSCopying, NSSecureCoding, SCNAnimatable {

		[Static, Export ("particleSystem")]
		SCNParticleSystem Create ();

		[Static, Export ("particleSystemNamed:inDirectory:")]
		SCNParticleSystem Create (string name, [NullAllowed] string directory);

		[Export ("emissionDuration")]
		nfloat EmissionDuration { get; set; }

		[Export ("emissionDurationVariation")]
		nfloat EmissionDurationVariation { get; set; }

		[Export ("idleDuration")]
		nfloat IdleDuration { get; set; }

		[Export ("idleDurationVariation")]
		nfloat IdleDurationVariation { get; set; }

		[Export ("loops")]
		bool Loops { get; set; }

		[Export ("birthRate")]
		nfloat BirthRate { get; set; }

		[Export ("birthRateVariation")]
		nfloat BirthRateVariation { get; set; }

		[Export ("warmupDuration")]
		nfloat WarmupDuration { get; set; }

		[Export ("emitterShape", ArgumentSemantic.Retain)]
		SCNGeometry EmitterShape { get; set; }

		[Export ("birthLocation")]
		SCNParticleBirthLocation BirthLocation { get; set; }

		[Export ("birthDirection")]
		SCNParticleBirthDirection BirthDirection { get; set; }

		[Export ("spreadingAngle")]
		nfloat SpreadingAngle { get; set; }

		[Export ("emittingDirection")]
		SCNVector3 EmittingDirection { get; set; }

		[Export ("acceleration")]
		SCNVector3 Acceleration { get; set; }

		[Export ("local")]
		bool Local { [Bind ("isLocal")] get; set; }

		[Export ("particleAngle")]
		nfloat ParticleAngle { get; set; }

		[Export ("particleAngleVariation")]
		nfloat ParticleAngleVariation { get; set; }

		[Export ("particleVelocity")]
		nfloat ParticleVelocity { get; set; }

		[Export ("particleVelocityVariation")]
		nfloat ParticleVelocityVariation { get; set; }

		[Export ("particleAngularVelocity")]
		nfloat ParticleAngularVelocity { get; set; }

		[Export ("particleAngularVelocityVariation")]
		nfloat ParticleAngularVelocityVariation { get; set; }

		[Export ("particleLifeSpan")]
		nfloat ParticleLifeSpan { get; set; }

		[Export ("particleLifeSpanVariation")]
		nfloat ParticleLifeSpanVariation { get; set; }

		[Export ("systemSpawnedOnDying", ArgumentSemantic.Retain)]
		SCNParticleSystem SystemSpawnedOnDying { get; set; }

		[Export ("systemSpawnedOnCollision", ArgumentSemantic.Retain)]
		SCNParticleSystem SystemSpawnedOnCollision { get; set; }

		[Export ("systemSpawnedOnLiving", ArgumentSemantic.Retain)]
		SCNParticleSystem SystemSpawnedOnLiving { get; set; }

		[Export ("particleImage", ArgumentSemantic.Retain)]
		NSObject ParticleImage { get; set; }

		[Export ("imageSequenceColumnCount")]
		nuint ImageSequenceColumnCount { get; set; }

		[Export ("imageSequenceRowCount")]
		nuint ImageSequenceRowCount { get; set; }

		[Export ("imageSequenceInitialFrame")]
		nfloat ImageSequenceInitialFrame { get; set; }

		[Export ("imageSequenceInitialFrameVariation")]
		nfloat ImageSequenceInitialFrameVariation { get; set; }

		[Export ("imageSequenceFrameRate")]
		nfloat ImageSequenceFrameRate { get; set; }

		[Export ("imageSequenceFrameRateVariation")]
		nfloat ImageSequenceFrameRateVariation { get; set; }

		[Export ("imageSequenceAnimationMode")]
		SCNParticleImageSequenceAnimationMode ImageSequenceAnimationMode { get; set; }

		[Export ("particleColor", ArgumentSemantic.Retain)]
		NSColor ParticleColor { get; set; }

		[Export ("particleColorVariation")]
		SCNVector4 ParticleColorVariation { get; set; }

		[Export ("particleSize")]
		nfloat ParticleSize { get; set; }

		[Export ("particleSizeVariation")]
		nfloat ParticleSizeVariation { get; set; }

		[Export ("blendMode")]
		SCNParticleBlendMode BlendMode { get; set; }

		[Export ("blackPassEnabled")]
		bool BlackPassEnabled { [Bind ("isBlackPassEnabled")] get; set; }

		[Export ("orientationMode")]
		SCNParticleOrientationMode OrientationMode { get; set; }

		[Export ("sortingMode")]
		SCNParticleSortingMode SortingMode { get; set; }

		[Export ("lightingEnabled")]
		bool LightingEnabled { [Bind ("isLightingEnabled")] get; set; }

		[Export ("affectedByGravity")]
		bool AffectedByGravity { get; set; }

		[Export ("affectedByPhysicsFields")]
		bool AffectedByPhysicsFields { get; set; }

		[Export ("particleDiesOnCollision")]
		bool ParticleDiesOnCollision { get; set; }

		[Export ("colliderNodes", ArgumentSemantic.Copy)]
		SCNNode [] ColliderNodes { get; set; }

		[Export ("particleMass")]
		nfloat ParticleMass { get; set; }

		[Export ("particleMassVariation")]
		nfloat ParticleMassVariation { get; set; }

		[Export ("particleBounce")]
		nfloat ParticleBounce { get; set; }

		[Export ("particleBounceVariation")]
		nfloat ParticleBounceVariation { get; set; }

		[Export ("particleFriction")]
		nfloat ParticleFriction { get; set; }

		[Export ("particleFrictionVariation")]
		nfloat ParticleFrictionVariation { get; set; }

		[Export ("particleCharge")]
		nfloat ParticleCharge { get; set; }
		
		[Export ("particleChargeVariation")]
		nfloat ParticleChargeVariation { get; set; }
		
		[Export ("dampingFactor")]
		nfloat DampingFactor { get; set; }

		[Export ("speedFactor")]
		nfloat SpeedFactor { get; set; }

		[Export ("stretchFactor")]
		nfloat StretchFactor { get; set; }

		[Export ("fresnelExponent")]
		nfloat FresnelExponent { get; set; }

		[Export ("propertyControllers", ArgumentSemantic.Copy), NullAllowed]
		NSDictionary WeakPropertyControllers { get; set; }

		[Export ("reset")]
		void Reset ();

		[Export ("handleEvent:forProperties:withBlock:")]
		void HandleEvent (SCNParticleEvent evnt, NSString [] particleProperties, SCNParticleEventHandler handler);

		[Export ("addModifierForProperties:atStage:withBlock:")]
		void AddModifier (NSString [] properties, SCNParticleModifierStage stage, SCNParticleModifierHandler handler);

		[Export ("removeModifiersOfStage:")]
		void RemoveModifiers (SCNParticleModifierStage stage);

		[Export ("removeAllModifiers")]
		void RemoveAllModifiers ();

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("orientationDirection", ArgumentSemantic.Assign)]
		SCNVector3 OrientationDirection { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("particleIntensity")]
		nfloat ParticleIntensity { get; set; }

		[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
		[Export ("particleIntensityVariation")]
		nfloat ParticleIntensityVariation { get; set; }
	}

	[Watch (3,0)]
	[Static]
	interface SCNParticleProperty {
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyPosition")]
		NSString Position { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyAngle")]
		NSString Angle { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyRotationAxis")]
		NSString RotationAxis { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyVelocity")]
		NSString Velocity { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyAngularVelocity")]
		NSString AngularVelocity { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyLife")]
		NSString Life { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyColor")]
		NSString Color { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyOpacity")]
		NSString Opacity { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertySize")]
		NSString Size { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyFrame")]
		NSString Frame { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyFrameRate")]
		NSString FrameRate { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyBounce")]
		NSString Bounce { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyCharge")]
		NSString Charge { get; }
		
		[Mac (10,10), iOS (8,0)]
		[Field ("SCNParticlePropertyFriction")]
		NSString Friction { get; }

		[Mac (10, 10), iOS (8, 0)]
		[Field ("SCNParticlePropertyContactPoint")]
		NSString ContactPoint { get; }

		[Mac (10, 10), iOS (8, 0)]
		[Field ("SCNParticlePropertyContactNormal")]
		NSString ContactNormal { get; }
	}
	
	[Mac (10,10), iOS (8,0)]
	delegate void SCNParticleEventHandler (IntPtr data, IntPtr dataStride, IntPtr indices, nint count);

	[Mac (10,10), iOS (8,0)]
	delegate void SCNParticleModifierHandler (IntPtr data, IntPtr dataStride, nint start, nint end, float /* float, not CGFloat */ deltaTime);

	[Watch (3,0)]
	[Mac (10,10), iOS (8,0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface SCNParticlePropertyController : NSSecureCoding, NSCopying {

		[NoWatch]
		[Static, Export ("controllerWithAnimation:")]
		SCNParticlePropertyController Create (CAAnimation animation);

		[NoWatch]
		[Export ("animation", ArgumentSemantic.Retain)]
		CAAnimation Animation { get; set; }

		[Export ("inputMode")]
		SCNParticleInputMode InputMode { get; set; }

		[Export ("inputScale")]
		nfloat InputScale { get; set; }

		[Export ("inputBias")]
		nfloat InputBias { get; set; }

		[Export ("inputOrigin", ArgumentSemantic.Weak)]
		SCNNode InputOrigin { get; set; }

		[Export ("inputProperty")]
		NSString InputProperty { get; set; }
	}

	[Watch (3,0)]
	[iOS (9,0)][Mac (10,11)]
	[BaseType (typeof (SCNConstraint))]
	interface SCNBillboardConstraint {
		[Static]
		[Export ("billboardConstraint")]
		SCNBillboardConstraint Create ();

		[Export ("freeAxes", ArgumentSemantic.Assign)]
		SCNBillboardAxis FreeAxes { get; set; }
	}

	[Watch (3,0)]
	[iOS (9,0)][Mac (10,11)]
	[BaseType (typeof (SCNNode))]
	[DisableDefaultCtor]
	interface SCNReferenceNode : NSCoding {
		[Export ("initWithURL:")]
		[DesignatedInitializer]
		IntPtr Constructor (NSUrl referenceUrl);

		[Static]
		[Export ("referenceNodeWithURL:")]
		SCNReferenceNode CreateFromUrl (NSUrl referenceUrl);

		[Export ("referenceURL", ArgumentSemantic.Copy)]
		NSUrl ReferenceUrl { get; set; }

		[Export ("loadingPolicy", ArgumentSemantic.Assign)]
		SCNReferenceLoadingPolicy LoadingPolicy { get; set; }

		[Export ("load")]
		void Load ();

		[Export ("unload")]
		void Unload ();

		[Export ("loaded")]
		bool Loaded { [Bind ("isLoaded")] get; }
	}

	interface ISCNBufferStream { }

	[Watch (3,0)]
	[iOS (9,0)][Mac (10,11)]
	[Protocol]
	interface SCNBufferStream {
		[Abstract]
		[Export ("writeBytes:length:")]
		unsafe void Length (IntPtr bytes, nuint length);
	}

	[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof(NSObject))]
	interface SCNTimingFunction : NSSecureCoding
	{
		[Static]
		[Export ("functionWithTimingMode:")]
		SCNTimingFunction Create (SCNActionTimingMode timingMode);
	
		[Static, NoWatch]
		[Export ("functionWithCAMediaTimingFunction:")]
		SCNTimingFunction Create (CAMediaTimingFunction caTimingFunction);
	}

	// Use the Swift name SCNAnimationProtocol since it conflicts with the type name
	[Protocol (Name="SCNAnimation")]
	interface SCNAnimationProtocol {
	}

	interface ISCNAnimationProtocol {}

	[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof(NSObject))]
	interface SCNAnimation : SCNAnimationProtocol, NSCopying, NSSecureCoding
	{
		[Static]
		[Export ("animationWithContentsOfURL:")]
		SCNAnimation FromUrl (NSUrl animationUrl);
	
		[Static]
		[Export ("animationNamed:")]
		SCNAnimation FromName (string animationName);
	
		[Static, NoWatch]
		[Export ("animationWithCAAnimation:")]
		SCNAnimation FromCAAnimation (CAAnimation caAnimation);
	
		[Export ("duration")]
		double Duration { get; set; }
	
		[NullAllowed, Export ("keyPath")]
		string KeyPath { get; set; }
	
		[Export ("timingFunction", ArgumentSemantic.Retain)]
		SCNTimingFunction TimingFunction { get; set; }
	
		[Export ("blendInDuration")]
		double BlendInDuration { get; set; }
	
		[Export ("blendOutDuration")]
		double BlendOutDuration { get; set; }
	
		[Export ("removedOnCompletion")]
		bool RemovedOnCompletion { [Bind ("isRemovedOnCompletion")] get; set; }
	
		[Export ("appliedOnCompletion")]
		bool AppliedOnCompletion { [Bind ("isAppliedOnCompletion")] get; set; }
	
		[Export ("repeatCount")]
		nfloat RepeatCount { get; set; }
	
		[Export ("autoreverses")]
		bool Autoreverses { get; set; }
	
		[Export ("startDelay")]
		double StartDelay { get; set; }
	
		[Export ("timeOffset")]
		double TimeOffset { get; set; }
	
		[Export ("fillsForward")]
		bool FillsForward { get; set; }
	
		[Export ("fillsBackward")]
		bool FillsBackward { get; set; }
	
		[Export ("usesSceneTimeBase")]
		bool UsesSceneTimeBase { get; set; }
	
		[NullAllowed, Export ("animationDidStart", ArgumentSemantic.Copy)]
		SCNAnimationDidStartHandler AnimationDidStart { get; set; }
	
		[NullAllowed, Export ("animationDidStop", ArgumentSemantic.Copy)]
		SCNAnimationDidStopHandler AnimationDidStop { get; set; }
	
		[NullAllowed, Export ("animationEvents", ArgumentSemantic.Copy)]
		SCNAnimationEvent[] AnimationEvents { get; set; }
	
		[Export ("additive")]
		bool Additive { [Bind ("isAdditive")] get; set; }
	
		[Export ("cumulative")]
		bool Cumulative { [Bind ("isCumulative")] get; set; }
	}
	
	[Watch (4,0), TV (11,0), Mac (10, 13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof(NSObject))]
	interface SCNAnimationPlayer : SCNAnimatable, NSCopying, NSSecureCoding
	{
		[Static]
		[Export ("animationPlayerWithAnimation:")]
		SCNAnimationPlayer FromAnimation (SCNAnimation animation);
	
		[Export ("animation")]
		SCNAnimation Animation { get; }
	
		[Export ("speed")]
		nfloat Speed { get; set; }
	
		[Export ("blendFactor")]
		nfloat BlendFactor { get; set; }
	
		[Export ("paused")]
		bool Paused { get; set; }
	
		[Export ("play")]
		void Play ();
	
		[Export ("stop")]
		void Stop ();
	
		[Export ("stopWithBlendOutDuration:")]
		void StopWithBlendOutDuration (double seconds);
	}

	[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof (SCNConstraint))]
	interface SCNDistanceConstraint {

		[Static]
		[Export ("distanceConstraintWithTarget:")]
		SCNDistanceConstraint FromTarget ([NullAllowed] SCNNode target);

		[NullAllowed, Export ("target", ArgumentSemantic.Retain)]
		SCNNode Target { get; set; }

		[Export ("minimumDistance")]
		nfloat MinimumDistance { get; set; }

		[Export ("maximumDistance")]
		nfloat MaximumDistance { get; set; }
	}

	[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof (SCNConstraint))]
	interface SCNReplicatorConstraint {

		[Static]
		[Export ("replicatorConstraintWithTarget:")]
		SCNReplicatorConstraint FromTarget ([NullAllowed] SCNNode target);

		[NullAllowed, Export ("target", ArgumentSemantic.Retain)]
		SCNNode Target { get; set; }

		[Export ("replicatesOrientation")]
		bool ReplicatesOrientation { get; set; }

		[Export ("replicatesPosition")]
		bool ReplicatesPosition { get; set; }

		[Export ("replicatesScale")]
		bool ReplicatesScale { get; set; }

		[Export ("orientationOffset", ArgumentSemantic.Assign)]
		SCNQuaternion OrientationOffset { get; set; }

		[Export ("positionOffset", ArgumentSemantic.Assign)]
		SCNVector3 PositionOffset { get; set; }

		[Export ("scaleOffset", ArgumentSemantic.Assign)]
		SCNVector3 ScaleOffset { get; set; }
	}

	[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof (SCNConstraint))]
	interface SCNAccelerationConstraint {

		[Static]
		[Export ("accelerationConstraint")]
		SCNAccelerationConstraint Create ();

		[Export ("maximumLinearAcceleration")]
		nfloat MaximumLinearAcceleration { get; set; }

		[Export ("maximumLinearVelocity")]
		nfloat MaximumLinearVelocity { get; set; }

		[Export ("decelerationDistance")]
		nfloat DecelerationDistance { get; set; }

		[Export ("damping")]
		nfloat Damping { get; set; }
	}

	[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof (SCNConstraint))]
	interface SCNSliderConstraint {

		[Static]
		[Export ("sliderConstraint")]
		SCNSliderConstraint Create ();

		[Export ("collisionCategoryBitMask")]
		nuint CollisionCategoryBitMask { get; set; }

		[Export ("radius")]
		nfloat Radius { get; set; }

		[Export ("offset", ArgumentSemantic.Assign)]
		SCNVector3 Offset { get; set; }
	}

	interface ISCNAvoidOccluderConstraintDelegate { }

	[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface SCNAvoidOccluderConstraintDelegate {

		[Export ("avoidOccluderConstraint:shouldAvoidOccluder:forNode:")]
		bool ShouldAvoidOccluder (SCNAvoidOccluderConstraint constraint, SCNNode occluder, SCNNode node);

		[Export ("avoidOccluderConstraint:didAvoidOccluder:forNode:")]
		void DidAvoidOccluder (SCNAvoidOccluderConstraint constraint, SCNNode occluder, SCNNode node);
	}

	[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof (SCNConstraint))]
	interface SCNAvoidOccluderConstraint {

		[Static]
		[Export ("avoidOccluderConstraintWithTarget:")]
		SCNAvoidOccluderConstraint FromTarget ([NullAllowed] SCNNode target);

		[NullAllowed, Export ("delegate", ArgumentSemantic.Assign)]
		ISCNAvoidOccluderConstraintDelegate Delegate { get; set; }

		[NullAllowed, Export ("target", ArgumentSemantic.Retain)]
		SCNNode Target { get; set; }

		[Export ("occluderCategoryBitMask")]
		nuint OccluderCategoryBitMask { get; set; }

		[Export ("bias")]
		nfloat Bias { get; set; }
	}

	[Watch (4,0), TV (11,0), Mac (10,13, onlyOn64: true), iOS (11,0)]
	[BaseType (typeof(SCNPhysicsBehavior))]
	interface SCNPhysicsConeTwistJoint {

		[Static]
		[Export ("jointWithBodyA:frameA:bodyB:frameB:")]
		SCNPhysicsConeTwistJoint FromBodies (SCNPhysicsBody bodyA, SCNMatrix4 frameA, SCNPhysicsBody bodyB, SCNMatrix4 frameB);

		[Static]
		[Export ("jointWithBody:frame:")]
		SCNPhysicsConeTwistJoint FromBody (SCNPhysicsBody body, SCNMatrix4 frame);

		[Export ("bodyA")]
		SCNPhysicsBody BodyA { get; }

		[Export ("frameA", ArgumentSemantic.Assign)]
		SCNMatrix4 FrameA { get; set; }

		[NullAllowed, Export ("bodyB")]
		SCNPhysicsBody BodyB { get; }

		[Export ("frameB", ArgumentSemantic.Assign)]
		SCNMatrix4 FrameB { get; set; }

		[Export ("maximumAngularLimit1")]
		nfloat MaximumAngularLimit1 { get; set; }

		[Export ("maximumAngularLimit2")]
		nfloat MaximumAngularLimit2 { get; set; }

		[Export ("maximumTwistAngle")]
		nfloat MaximumTwistAngle { get; set; }
	}


}