# encoding: utf-8
# module Rhino.Render calls itself Render
# from RhinoCommon,Version=5.1.30000.16,Culture=neutral,PublicKeyToken=552281e97c755530
# by generator 1.145
""" NamespaceTracker represent a CLS namespace. """
# no imports

# no functions
# classes

class CachedTextureCoordinates(CommonObject,IDisposable,ISerializable,IList[Point3d],ICollection[Point3d],IEnumerable[Point3d],IEnumerable):
 """ Used for cached texture coordinates """
 def Add(self,item):
  """
  Add(self: CachedTextureCoordinates,item: Point3d)

   IList implementation,this list is always read-only so calling this

     will cause a 

    NotSupportedException to be thrown.
  """
  pass
 def Clear(self):
  """
  Clear(self: CachedTextureCoordinates)

   IList implementation,this list is always read-only so calling this

     will cause a 

    NotSupportedException to be thrown.
  """
  pass
 def ConstructConstObject(self,*args):
  """
  ConstructConstObject(self: CommonObject,parentObject: object,subobject_index: int)

   Assigns a parent object and a subobject index to this.

  

   parentObject: The parent object.

   subobject_index: The subobject index.
  """
  pass
 def Contains(self,item):
  """
  Contains(self: CachedTextureCoordinates,item: Point3d) -> bool

  

   Determines whether this collection contains a specific value.
  """
  pass
 def CopyTo(self,array,arrayIndex):
  """
  CopyTo(self: CachedTextureCoordinates,array: Array[Point3d],arrayIndex: int)

   Copies the elements of the this collection to an System.Array,

     starting at a 

    particular System.Array index.

  

  

   array: The one-dimensional System.Array that is the destination of the

     elements copied 

    from this collection. The System.Array must have

     zero-based indexing.

  

   arrayIndex: The zero-based index in array at which copying begins.
  """
  pass
 def Dispose(self):
  """
  Dispose(self: CommonObject,disposing: bool)

   For derived class implementers.

     This method is called with argument true when class 

    user calls Dispose(),while with argument false when

     the Garbage Collector invokes 

    the finalizer,or Finalize() method.You must reclaim all used unmanaged resources in both cases,

    and can use this chance to call Dispose on disposable fields if the argument is true.Also,you 

    must call the base virtual method within your overriding method.

  

  

   disposing: true if the call comes from the Dispose() method; false if it comes from the Garbage Collector 

    finalizer.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: CachedTextureCoordinates) -> IEnumerator[Point3d]

  

   Returns an enumerator that iterates through this collection.

   Returns: A enumerator that can be used to iterate through this collection.
  """
  pass
 def IndexOf(self,item):
  """
  IndexOf(self: CachedTextureCoordinates,item: Point3d) -> int

  

   Determines the index of a specific point in this collection.

  

   item: The point (UV or UVW) to locate in this collection.

   Returns: The index of item if found in the list; otherwise,-1.
  """
  pass
 def Insert(self,index,item):
  """
  Insert(self: CachedTextureCoordinates,index: int,item: Point3d)

   IList implementation,this list is always read-only so calling this

     will cause a 

    NotSupportedException to be thrown.
  """
  pass
 def NonConstOperation(self,*args):
  """
  NonConstOperation(self: CommonObject)

   For derived classes implementers.

     Defines the necessary implementation to free the 

    instance from being const.
  """
  pass
 def OnSwitchToNonConst(self,*args):
  """
  OnSwitchToNonConst(self: CommonObject)

   Is called when a non-const operation first occurs.
  """
  pass
 def Remove(self,item):
  """
  Remove(self: CachedTextureCoordinates,item: Point3d) -> bool

  

   IList implementation,this list is always read-only so calling this

     will cause a 

    NotSupportedException to be thrown.
  """
  pass
 def RemoveAt(self,index):
  """
  RemoveAt(self: CachedTextureCoordinates,index: int)

   IList implementation,this list is always read-only so calling this

     will cause a 

    NotSupportedException to be thrown.
  """
  pass
 def TryGetAt(self,index,u,v,w):
  """
  TryGetAt(self: CachedTextureCoordinates,index: int) -> (bool,float,float,float)

  

   Use this method to iterate the cached texture coordinate array.

  

   index: Index for the vertex to fetch.

   Returns: Returns true if index is valid; otherwise returns false.
  """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """ __contains__(self: ICollection[Point3d],item: Point3d) -> bool """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 def __setitem__(self,*args):
  """ x.__setitem__(i,y) <==> x[i]= """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Number of cached coordinates.



Get: Count(self: CachedTextureCoordinates) -> int



"""

 Dim=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Coordinate dimension: 2=UV,3=UVW



Get: Dim(self: CachedTextureCoordinates) -> int



"""

 IsReadOnly=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """This collection is always read-only



Get: IsReadOnly(self: CachedTextureCoordinates) -> bool



"""

 MappingId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The texture mapping Id.



Get: MappingId(self: CachedTextureCoordinates) -> Guid



"""



class ContentUndoBlocker(object,IDisposable):
 """ ContentUndoBlocker() """
 def Dispose(self):
  """ Dispose(self: ContentUndoBlocker) """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass

class CreatePreviewEventArgs(EventArgs):
 """ Used in RenderPlugIn virtual CreatePreview function """
 Cancel=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get set by Rhino if the preview generation should be canceled for this



Get: Cancel(self: CreatePreviewEventArgs) -> bool



"""

 Environment=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The environment that the previewed object is rendered in.



Get: Environment(self: CreatePreviewEventArgs) -> RenderEnvironment



"""

 Id=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Unique Id for this scene.



Get: Id(self: CreatePreviewEventArgs) -> int



"""

 Lights=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Lights(self: CreatePreviewEventArgs) -> List[Light]



"""

 Objects=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Objects(self: CreatePreviewEventArgs) -> List[SceneObject]



"""

 PreviewContent=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The content being previewed.



Get: PreviewContent(self: CreatePreviewEventArgs) -> RenderContent



"""

 PreviewImage=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Initially null.  If this image is set,then this image will be used for

   the preview.  If never set,the default internal simulation preview will

   be used.



Get: PreviewImage(self: CreatePreviewEventArgs) -> Bitmap



Set: PreviewImage(self: CreatePreviewEventArgs)=value

"""

 PreviewImageSize=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Pixel size of the image that is being requested for the preview scene



Get: PreviewImageSize(self: CreatePreviewEventArgs) -> Size



"""

 Quality=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Quality of the preview image that is being requested for the preview scene



Get: Quality(self: CreatePreviewEventArgs) -> PreviewSceneQuality



"""

 Reason=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Reason the preview is getting generated



Get: Reason(self: CreatePreviewEventArgs) -> CreatePreviewReason



"""

 Viewport=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Viewport(self: CreatePreviewEventArgs) -> ViewportInfo



"""


 SceneObject=None


class CreatePreviewReason(Enum,IComparable,IFormattable,IConvertible):
 """
 Reason the content preview is being generated

 

 enum CreatePreviewReason,values: ContentChanged (0),Other (99),RefreshDisplay (2),ViewChanged (1)
 """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 ContentChanged=None
 Other=None
 RefreshDisplay=None
 value__=None
 ViewChanged=None


class CreateTexture2dPreviewEventArgs(EventArgs):
 # no doc
 PreviewImage=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Initially null.  If this image is set,then this image will be used for

   the preview.  If never set,the default internal simulation preview will

   be used.



Get: PreviewImage(self: CreateTexture2dPreviewEventArgs) -> Bitmap



Set: PreviewImage(self: CreateTexture2dPreviewEventArgs)=value

"""

 PreviewImageSize=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Pixel size of the image that is being requested for the preview scene



Get: PreviewImageSize(self: CreateTexture2dPreviewEventArgs) -> Size



"""



class CustomRenderMeshProvider(object):
 """
 You must call CustomRenderMeshProvider.RegisterProviders() from your

    plug-ins OnLoad override for each assembly containing a custom mesh

    provider.  Only publicly exported classes derived from

    CustomRenderMeshProvider with a public constructor that has no parameters

    will get registered.
 """
 @staticmethod
 def AllObjectsChanged():
  """
  AllObjectsChanged()

   Call this method if your render meshes change.
  """
  pass
 def BoundingBox(self,vp,obj,requestingPlugIn,preview):
  """
  BoundingBox(self: CustomRenderMeshProvider,vp: ViewportInfo,obj: RhinoObject,requestingPlugIn: Guid,preview: bool) -> BoundingBox

  

   Returns a bounding box for the custom render meshes for the given object.

  

   vp: The viewport being rendered.

   obj: The Rhino object of interest.

   requestingPlugIn: UUID of the RDK plug-in requesting the meshes.

   preview: Type of mesh to build.

   Returns: A bounding box value.
  """
  pass
 def BuildCustomMeshes(self,vp,objMeshes,requestingPlugIn,meshType):
  """
  BuildCustomMeshes(self: CustomRenderMeshProvider,vp: ViewportInfo,objMeshes: RenderPrimitiveList,requestingPlugIn: Guid,meshType: bool) -> bool

  

   Build custom render mesh(es).

  

   vp: The viewport being rendered.

   objMeshes: The meshes class to populate with custom meshes.

   requestingPlugIn: UUID of the RDK plug-in requesting the meshes.

   meshType: Type of mesh to build.

   Returns: true if operation was successful.
  """
  pass
 @staticmethod
 def ObjectChanged(obj):
  """ ObjectChanged(obj: RhinoObject) """
  pass
 @staticmethod
 def RegisterProviders(assembly,pluginId):
  """
  RegisterProviders(assembly: Assembly,pluginId: Guid)

   Call this method once from your plug-ins OnLoad override for each

     assembly 

    containing a custom mesh provider.  Only publicly exported

     classes derived from 

    CustomRenderMeshProvider with a public constructor

     that has no parameters will get 

    registered.

  

  

   assembly: Assembly to search for valid CustomRenderMeshProvider derived classes.

   pluginId: The plug-in that owns the custom mesh providers.
  """
  pass
 def WillBuildCustomMeshes(self,vp,obj,requestingPlugIn,preview):
  """
  WillBuildCustomMeshes(self: CustomRenderMeshProvider,vp: ViewportInfo,obj: RhinoObject,requestingPlugIn: Guid,preview: bool) -> bool

  

   Determines if custom render meshes will be built for a particular object.

  

   vp: The viewport being rendered.

   obj: The Rhino object of interest.

   requestingPlugIn: UUID of the RDK plug-in requesting the meshes.

   preview: Type of mesh to build.

   Returns: true if custom meshes will be built.
  """
  pass
 Name=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The name of the provider for UI display.



Get: Name(self: CustomRenderMeshProvider) -> str



"""



class Decal(object,IDisposable):
 """ Represents a decal,or a picture that can be moved on an object. """
 def ConstPointer(self):
  """ ConstPointer(self: Decal) -> IntPtr """
  pass
 @staticmethod
 def Create(createParams):
  """ Create(createParams: DecalCreateParams) -> Decal """
  pass
 def Dispose(self,isDisposing=None):
  """ Dispose(self: Decal,isDisposing: bool)Dispose(self: Decal) """
  pass
 def NonConstPointer(self):
  """ NonConstPointer(self: Decal) -> IntPtr """
  pass
 def TryGetColor(self,point,normal,colInOut,uvOut):
  """
  TryGetColor(self: Decal,point: Point3d,normal: Vector3d,colInOut: Color4f,uvOut: Point2d) -> (bool,Color4f,Point2d)

  

   Blend color with the decal color at a given point.

  

   point: The point in space or,if the decal is uv-mapped,the uv-coordinate of that point.

   normal: The face normal of the given point.

   colInOut: The color to blend the decal color to.

   uvOut: the UV on the texture that the color point was read from.

   Returns: true if the given point hits the decal,else false.
  """
  pass
 def UVBounds(self,minUOut,minVOut,maxUOut,maxVOut):
  """
  UVBounds(self: Decal,minUOut: float,minVOut: float,maxUOut: float,maxVOut: float) -> (float,float,float,float)

  

   The UV bounds of the decal. Only used when mapping is UV.
  """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 DecalMapping=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the mapping of the decal.



Get: DecalMapping(self: Decal) -> DecalMapping



"""

 DecalProjection=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the decal's projection. Used only when mapping is planar.



Get: DecalProjection(self: Decal) -> DecalProjection



"""

 EndLatitude=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the stop latitude of the decal's sweep. Only used when mapping is cylindrical or spherical.



Get: EndLatitude(self: Decal) -> float



"""

 EndLongitude=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the stop longitude of the decal's sweep. Only used when mapping is spherical.



Get: EndLongitude(self: Decal) -> float



"""

 Height=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the height of the decal. Only used when mapping is cylindrical.



Get: Height(self: Decal) -> float



"""

 Id=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the decal ID associated with this decal.



Get: Id(self: Decal) -> int



"""

 MapToInside=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Used only when mapping is cylindrical or spherical.



Get: MapToInside(self: Decal) -> bool



"""

 Origin=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the origin of the decal in world space.



Get: Origin(self: Decal) -> Point3d



"""

 Radius=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the radius of the decal. Only used when mapping is cylindrical or spherical.



Get: Radius(self: Decal) -> float



"""

 StartLatitude=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the start latitude of the decal's sweep. Only used when mapping is cylindrical or spherical.



Get: StartLatitude(self: Decal) -> float



"""

 StartLongitude=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the start longitude of the decal's sweep. Only used when mapping is spherical.



Get: StartLongitude(self: Decal) -> float



"""

 TextureInstanceId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the texture ID for this decal.



Get: TextureInstanceId(self: Decal) -> Guid



"""

 Transparency=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the decal's transparency in the range 0 to 1.



Get: Transparency(self: Decal) -> float



"""

 VectorAcross=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the vector across. For cylindrical and spherical mapping,the vector is unitized.



Get: VectorAcross(self: Decal) -> Vector3d



"""

 VectorUp=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """For cylindrical and spherical mapping,the vector is unitized.



Get: VectorUp(self: Decal) -> Vector3d



"""



class DecalMapping(Enum,IComparable,IFormattable,IConvertible):
 """ enum DecalMapping,values: Cylindrical (1),Planar (0),Spherical (2),UV (3) """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Cylindrical=None
 Planar=None
 Spherical=None
 UV=None
 value__=None


class DecalProjection(Enum,IComparable,IFormattable,IConvertible):
 """ enum DecalProjection,values: Backward (1),Both (2),Forward (0) """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Backward=None
 Both=None
 Forward=None
 value__=None


class Decals(object,IEnumerable[Decal],IEnumerable):
 """ Represents all the decals of an object. """
 def Add(self,decal):
  """
  Add(self: Decals,decal: Decal) -> UInt32

  

   Add a new Decal to the decals list,use Decal.Create to create

     a new decal instance 

    to add.
  """
  pass
 def Clear(self):
  """ Clear(self: Decals) """
  pass
 def GetEnumerator(self):
  """ GetEnumerator(self: Decals) -> IEnumerator[Decal] """
  pass
 def Remove(self,decal):
  """ Remove(self: Decals,decal: Decal) -> bool """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """ __contains__[Decal](enumerable: IEnumerable[Decal],value: Decal) -> bool """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass

class GroundPlane(object):
 """
 Represents an infinite plane for implementation by renderers.

    See Rhino.PlugIns.RenderPlugIn.SupportsFeature(Rhino.PlugIns.RenderPlugIn.RenderFeature)SupportsFeature.
 """
 Altitude=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Height above world XY plane in model units.



Get: Altitude(self: GroundPlane) -> float



Set: Altitude(self: GroundPlane)=value

"""

 Document=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Document this groundplane is associated with.



Get: Document(self: GroundPlane) -> RhinoDoc



"""

 Enabled=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Determines whether the document ground plane is enabled.



Get: Enabled(self: GroundPlane) -> bool



Set: Enabled(self: GroundPlane)=value

"""

 MaterialInstanceId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Id of material in material table for this ground plane.



Get: MaterialInstanceId(self: GroundPlane) -> Guid



Set: MaterialInstanceId(self: GroundPlane)=value

"""

 TextureOffset=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Texture mapping offset in world units.



Get: TextureOffset(self: GroundPlane) -> Vector2d



Set: TextureOffset(self: GroundPlane)=value

"""

 TextureRotation=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Texture mapping rotation around world origin + offset in degrees.



Get: TextureRotation(self: GroundPlane) -> float



Set: TextureRotation(self: GroundPlane)=value

"""

 TextureSize=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Texture mapping single UV span size in world units.



Get: TextureSize(self: GroundPlane) -> Vector2d



Set: TextureSize(self: GroundPlane)=value

"""


 Changed=None


class ImageFile(object):
 """ Controls interaction with RDK render image files """
 Deleted=None
 Loaded=None
 Saved=None
 __all__=[
  'Deleted',
  'Loaded',
  'Saved',
 ]


class ImageFileEvent(Enum,IComparable,IFormattable,IConvertible):
 """ enum ImageFileEvent,values: Deleted (2),Loaded (1),Saved (0) """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Deleted=None
 Loaded=None
 Saved=None
 value__=None


class ImageFileEventArgs(EventArgs):
 # no doc
 EllapsedTime=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: EllapsedTime(self: ImageFileEventArgs) -> int



"""

 Event=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Event(self: ImageFileEventArgs) -> ImageFileEvent



"""

 FileName=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: FileName(self: ImageFileEventArgs) -> str



"""

 RenderEngine=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: RenderEngine(self: ImageFileEventArgs) -> str



"""

 RenderEngineId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: RenderEngineId(self: ImageFileEventArgs) -> Guid



"""

 SessionId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: SessionId(self: ImageFileEventArgs) -> Guid



"""



class MappingTag(object):
 """
 Holds texture mapping information.

 

 MappingTag()
 """
 Id=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a map globally unique identifier.



Get: Id(self: MappingTag) -> Guid



Set: Id(self: MappingTag)=value

"""

 MappingCRC=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the cyclic redundancy check on the mapping.

   See also Rhino.RhinoMath.CRC32(System.UInt32,System.Byte[]).



Get: MappingCRC(self: MappingTag) -> UInt32



Set: MappingCRC(self: MappingTag)=value

"""

 MappingType=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a texture mapping type: linear,cylinder,etc...



Get: MappingType(self: MappingTag) -> TextureMappingType



Set: MappingType(self: MappingTag)=value

"""

 MeshTransform=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a 4x4 matrix tranform.



Get: MeshTransform(self: MappingTag) -> Transform



Set: MeshTransform(self: MappingTag)=value

"""



class NamedValue(object):
 """ NamedValue(name: str,value: object) """
 @staticmethod
 def __new__(self,name,value):
  """ __new__(cls: type,name: str,value: object) """
  pass
 Name=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Name(self: NamedValue) -> str



Set: Name(self: NamedValue)=value

"""

 Value=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Value(self: NamedValue) -> object



Set: Value(self: NamedValue)=value

"""



class PreviewSceneQuality(Enum,IComparable,IFormattable,IConvertible):
 """
 Quality levels when creating preview images

 

 enum PreviewSceneQuality,values: RealtimeQuick (-1),RefineFirstPass (1),RefineSecondPass (2),RefineThirdPass (3)
 """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 RealtimeQuick=None
 RefineFirstPass=None
 RefineSecondPass=None
 RefineThirdPass=None
 value__=None


class RenderContent(object,IDisposable):
 # no doc
 def AddAutomaticUserInterfaceSection(self,caption,id):
  """
  AddAutomaticUserInterfaceSection(self: RenderContent,caption: str,id: int) -> bool

  

   Add a new automatic user interface section,Field values which include

     prompts will 

    be automatically added to this section.

  

  

   caption: Expandable tab caption.

   id: Tab id which may be used later on to reference this tab.

   Returns: Returns true if the automatic tab section was added otherwise; returns

     false on 

    error.
  """
  pass
 def AddChild(self,renderContent):
  """ AddChild(self: RenderContent,renderContent: RenderContent) -> bool """
  pass
 @staticmethod
 def AddPersistentRenderContent(renderContent):
  """
  AddPersistentRenderContent(renderContent: RenderContent) -> bool

  

   Add a material,environment or texture to the internal RDK document lists as

     top 

    level content.  The content must have been returned from

     RenderContent::MakeCopy,

    NewContentFromType or a similar function that returns

     a non-document content.

  

  

   renderContent: The render content.

   Returns: true on success.
  """
  pass
 def AddUserInterfaceSection(self,classType,caption,createExpanded,createVisible):
  """
  AddUserInterfaceSection(self: RenderContent,classType: Type,caption: str,createExpanded: bool,createVisible: bool) -> UserInterfaceSection

  

   Add a new .NET control to an content expandable tab section,the height

     of the 

    createExpanded tabs client area will be the initial height of the

     specified 

    control.

  

  

   classType: The control class to create and embed as a child window in the

     expandable tab 

    client area.  This class type must be derived from

     IWin32Window or this method will 

    throw an ArgumentException.  Implement

     the IUserInterfaceSection interface in your 

    classType to get

     UserInterfaceSection notification.

  

   caption: Expandable tab caption.

   createExpanded: If this value is true then the new expandable tab section will

     initially be 

    expanded,if it is false it will be collapsed.

  

   createVisible: If this value is true then the new expandable tab section will

     initially be 

    visible,if it is false it will be hidden.

  

   Returns: Returns the UserInterfaceSection object used to manage the new 

     user control object.
  """
  pass
 def BindParameterToField(self,parameterName,*__args):
  """ BindParameterToField(self: RenderContent,parameterName: str,field: Field,setEvent: ChangeContexts)BindParameterToField(self: RenderContent,parameterName: str,childSlotName: str,field: Field,setEvent: ChangeContexts) """
  pass
 def ChangeChild(self,oldContent,newContent):
  """ ChangeChild(self: RenderContent,oldContent: RenderContent,newContent: RenderContent) -> bool """
  pass
 def ChildSlotAmount(self,childSlotName):
  """
  ChildSlotAmount(self: RenderContent,childSlotName: str) -> float

  

   Gets the amount property for the texture in the specified child slot.  Values are typically from 

    0.0 - 100.0

  

  

   childSlotName: Child slot name for the child
  """
  pass
 def ChildSlotNameFromParamName(self,paramName):
  """
  ChildSlotNameFromParamName(self: RenderContent,paramName: str) -> str

  

   A "child slot" is the specific "slot" that a child (usually a texture) occupies.

      

    This is generally the "use" of the child - in other words,the thing the child

      

    operates on.  Some examples are "color","transparency".

  

  

   paramName: The name of a parameter field. Since child textures will usually correspond with some

      

      parameter (they generally either replace or modify a parameter over UV space) these functions 

    are used to

     specify which parameter corresponded with child slot.  If there is no 

    correspondence,return the empty

     string.

  

   Returns: The default behavior for these functions is to return the input string.

      

    Sub-classes may (in the future) override these functions to provide different mappings.
  """
  pass
 def ChildSlotOn(self,childSlotName):
  """
  ChildSlotOn(self: RenderContent,childSlotName: str) -> bool

  

   Gets the on-ness property for the texture in the specified child slot.

  

   childSlotName: Child slot name for the child
  """
  pass
 @staticmethod
 def Create(type,*__args):
  """
  Create(type: Guid,parent: RenderContent,childSlotName: str,flags: ShowContentChooserFlags,doc: RhinoDoc) -> RenderContent

  Create(type: Type,parent: RenderContent,childSlotName: str,flags: ShowContentChooserFlags,doc: RhinoDoc) -> RenderContent

  Create(type: Guid,flags: ShowContentChooserFlags,doc: RhinoDoc) -> RenderContent

  Create(type: Type,flags: ShowContentChooserFlags,doc: RhinoDoc) -> RenderContent
  """
  pass
 def DeleteAllChildren(self,changeContexts):
  """ DeleteAllChildren(self: RenderContent,changeContexts: ChangeContexts) """
  pass
 def DeleteChild(self,childSlotName,changeContexts):
  """ DeleteChild(self: RenderContent,childSlotName: str,changeContexts: ChangeContexts) -> bool """
  pass
 def Dispose(self):
  """ Dispose(self: RenderContent) """
  pass
 def FindChild(self,childSlotName):
  """ FindChild(self: RenderContent,childSlotName: str) -> RenderContent """
  pass
 @staticmethod
 def FromId(document,id):
  """
  FromId(document: RhinoDoc,id: Guid) -> RenderContent

  

   Search for a content object based on its Id

  

   document: The Rhino document containing the content.

   id: Id of the content instance to search for.

   Returns: Returns the content object with the specified Id if it is found

     otherwise it 

    returns null.
  """
  pass
 def GetChildSlotParameter(self,parameterName,childSlotName):
  """
  GetChildSlotParameter(self: RenderContent,parameterName: str,childSlotName: str) -> object

  

   Extra requirements are a way of specifying extra functionality on parameters in the automatic 

    UI.

     Implement this function to specify additional functionality for automatic UI 

    sections or the texture summary.

     See IAutoUIExtraRequirements.h in the C++ RDK for 

    string definitions for the parameter names.

  

  

   parameterName: The parameter or field internal name to which this query applies

   childSlotName: The extra requirement parameter,as listed in IAutoUIExtraRequirements.h in the C++ RDK

   Returns: Call the base class if you do not support the extra requirement parameter.

     Current 

    supported return values are (int,bool,float,double,string,Guid,Color,Vector3d,Point3d,

    DateTime)
  """
  pass
 def GetParameter(self,parameterName):
  """
  GetParameter(self: RenderContent,parameterName: str) -> object

  

   Query the content instance for the value of a given named parameter.

     If you do not 

    support this parameter,call the base class.

  

  

   parameterName: Name of the parameter
  """
  pass
 def Icon(self,size):
  """
  Icon(self: RenderContent,size: Size) -> Bitmap

  

   Icon to display in the content browser,this bitmap needs to be valid for

     the life 

    of this content object,the content object that returns the bitmap

     is responsible 

    for disposing of the bitmap.

  

  

   size: Requested icon size

   Returns: Return Icon to display in the content browser.
  """
  pass
 def IsFactoryProductAcceptableAsChild(self,kindId,factoryKind,childSlotName):
  """
  IsFactoryProductAcceptableAsChild(self: RenderContent,kindId: Guid,factoryKind: str,childSlotName: str) -> bool

  

   Override this method to restrict the type of acceptable child content.

     The default 

    implementation of this method just returns true.

  

   Returns: Return true only if content with the specified kindId can be  accepted

     as a child 

    in the specified child slot.
  """
  pass
 @staticmethod
 def LoadFromFile(filename):
  """
  LoadFromFile(filename: str) -> RenderContent

  

   Loads content from a library file.  Does not add the content to the persistent content list.

     

       Use AddPersistantContent to add it to the list.

  

  

   filename: full path to the file to be loaded.

   Returns: The loaded content or null if an error occurred.
  """
  pass
 def ModifyRenderContentStyles(self,*args):
  """ ModifyRenderContentStyles(self: RenderContent,stylesToAdd: RenderContentStyles,stylesToRemove: RenderContentStyles) """
  pass
 def OnAddUserInterfaceSections(self,*args):
  """
  OnAddUserInterfaceSections(self: RenderContent)

   Override to provide UI sections to display in the editor.
  """
  pass
 def OnGetDefaultsInteractive(self,*args):
  """
  OnGetDefaultsInteractive(self: RenderContent,parentWindowHandle: IntPtr) -> bool

  

   Override this method to prompt user for information necessary to

     create a new 

    content object.  For example,if you are created a

     textured material you may prompt 

    the user for a bitmap file name

     prior to creating the textured material.

  

   Returns: If true is returned the content is created otherwise the creation

     is aborted.
  """
  pass
 def OpenInEditor(self):
  """
  OpenInEditor(self: RenderContent) -> bool

  

   Call this method to open the content in the relevant thumbnail editor

     and select it 

    for editing by the user. The content must be in the

     document or the call will fail.

  

   Returns: Returns true on success or false on error.
  """
  pass
 def OpenInModalEditor(self):
  """
  OpenInModalEditor(self: RenderContent) -> bool

  

   Call this method to open the content in the a modal version of the editor.

     The 

    content must be in the document or the call will fail.

  

   Returns: Returns true on success or false on error.
  """
  pass
 def ParamNameFromChildSlotName(self,childSlotName):
  """
  ParamNameFromChildSlotName(self: RenderContent,childSlotName: str) -> str

  

   A "child slot" is the specific "slot" that a child (usually a texture) occupies.

     

    This is generally the "use" of the child - in other words,the thing the child

     

    operates on.  Some examples are "color","transparency".

  

  

   childSlotName: The named of the child slot to receive the parameter name for.

   Returns: The default behaviour for these functions is to return the input string.  Sub-classes may (in 

    the future) override these functions to provide different mappings.
  """
  pass
 @staticmethod
 def RegisterContent(*__args):
  """
  RegisterContent(assembly: Assembly,pluginId: Guid) -> Array[Type]

  

   Call RegisterContent in your plug-in's OnLoad function in order to register all of the

     

    custom RenderContent classes in your assembly.

  

  

   assembly: Assembly where custom content is defined,this may be a plug-in assembly

     or another 

    assembly referenced by the plug-in.

  

   pluginId: Parent plug-in for this assembly.

   Returns: array of render content types registered on success. null on error.

  RegisterContent(plugin: PlugIn) -> Array[Type]

  

   Call RegisterContent in your plug-in's OnLoad function in order to register all of the

     

    custom RenderContent classes in your assembly.

  

   Returns: array of render content types registered on success. null on error.
  """
  pass
 def SetChild(self,renderContent,childSlotName,changeContexts):
  """ SetChild(self: RenderContent,renderContent: RenderContent,childSlotName: str,changeContexts: ChangeContexts) -> bool """
  pass
 def SetChildSlotAmount(self,childSlotName,amount,cc):
  """ SetChildSlotAmount(self: RenderContent,childSlotName: str,amount: float,cc: ChangeContexts) """
  pass
 def SetChildSlotOn(self,childSlotName,bOn,cc):
  """ SetChildSlotOn(self: RenderContent,childSlotName: str,bOn: bool,cc: ChangeContexts) """
  pass
 def SetChildSlotParameter(self,parameterName,childSlotName,value,sc):
  """ SetChildSlotParameter(self: RenderContent,parameterName: str,childSlotName: str,value: object,sc: ExtraRequirementsSetContexts) -> bool """
  pass
 def SetParameter(self,parameterName,value,changeContexts):
  """ SetParameter(self: RenderContent,parameterName: str,value: object,changeContexts: ChangeContexts) -> bool """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 ChildSlotName=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: ChildSlotName(self: RenderContent) -> str



Set: ChildSlotName(self: RenderContent)=value

"""

 Document=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get the document this content belongs to or null if the content has not

   yet been added to a document.  This will be null when content is

   generated for browsers or preview generation.



Get: Document(self: RenderContent) -> RhinoDoc



"""

 Fields=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Rhino.Render.Fields FieldDictionary which provides access to setting

   and retrieving field values.



Get: Fields(self: RenderContent) -> FieldDictionary



"""

 FilesToEmbed=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """A string array of full paths to files used by the content that may be

   embedded in .3dm files and library files (.rmtl,.renv,.rtex). The

   default implementation returns an empty string list. Override this to

   return the file name or file names used by your content. This is

   typically used by textures that reference files containing the texture

   imagery.



Get: FilesToEmbed(self: RenderContent) -> IEnumerable[str]



"""

 Hidden=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Determines if the content has the hidden flag set.



Get: Hidden(self: RenderContent) -> bool



Set: Hidden(self: RenderContent)=value

"""

 Id=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Instance identifier for this content.



Get: Id(self: RenderContent) -> Guid



Set: Id(self: RenderContent)=value

"""

 IsLocked=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Set this property to true prior to adding content to the document to

   lock the content browser editing UI methods.  Setting this to true will

   keep the browser from allowing things like deleting,renaming or

   changing content.  This is useful for custom child content that you

   want to be editable but persistent.  Setting this after adding content

   to the document will cause an exception to be thrown.



Get: IsLocked(self: RenderContent) -> bool



Set: IsLocked(self: RenderContent)=value

"""

 Name=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Instance name for this content.



Get: Name(self: RenderContent) -> str



Set: Name(self: RenderContent)=value

"""

 Notes=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Notes for this content.



Get: Notes(self: RenderContent) -> str



Set: Notes(self: RenderContent)=value

"""

 Parent=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Returns the top content in this parent/child chain.



Get: Parent(self: RenderContent) -> RenderContent



"""

 TopLevel=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Returns true if this content has no parent,false if it is the child of another content.



Get: TopLevel(self: RenderContent) -> bool



"""

 TopLevelParent=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Returns the top content in this parent/child chain.



Get: TopLevelParent(self: RenderContent) -> RenderContent



"""

 TypeDescription=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Description for your content type.  ie.  "Procedural checker pattern"



Get: TypeDescription(self: RenderContent) -> str



"""

 TypeName=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Name for your content type.  ie. "My .net Texture"



Get: TypeName(self: RenderContent) -> str



"""


 ChangeContexts=None
 ContentAdded=None
 ContentChanged=None
 ContentDeleting=None
 ContentFieldChanged=None
 ContentRenamed=None
 ContentReplaced=None
 ContentReplacing=None
 ContentUpdatePreview=None
 ExtraRequirementsSetContexts=None
 MatchDataResult=None
 ShowContentChooserFlags=None


class RenderContentEventArgs(EventArgs):
 # no doc
 Content=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Content(self: RenderContentEventArgs) -> RenderContent



"""



class RenderContentChangedEventArgs(RenderContentEventArgs):
 # no doc
 ChangeContext=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: ChangeContext(self: RenderContentChangedEventArgs) -> ChangeContexts



"""



class RenderContentFieldChangedEventArgs(RenderContentChangedEventArgs):
 # no doc
 FieldName=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: FieldName(self: RenderContentFieldChangedEventArgs) -> str



"""



class RenderContentKind(Enum,IComparable,IFormattable,IConvertible):
 """
 Defines constant values for all render content kinds,such as material,

    environment or texture.

 

 enum (flags) RenderContentKind,values: Environment (2),Material (1),None (0),Texture (4)
 """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Environment=None
 Material=None
 None=None
 Texture=None
 value__=None


class RenderContentSerializer(object):
 """
 Used to import and export custom render content types such as

    materials,environments and textures.  You must override

    RenderPlugIn.RenderContentSerializers() and return an array of

    derived RenderContentSerializer class types to add to the content

    browsers.
 """
 def Read(self,pathToFile):
  """
  Read(self: RenderContentSerializer,pathToFile: str) -> RenderContent

  

   Called to when importing a file,file should be parsed and converted to

     a valid 

    RenderContent object.

  

  

   pathToFile: Full path of the file to load.

   Returns: Returns a valid RenderContent object such as RenderMaterial if the file

     was 

    successfully parsed otherwise returns null.
  """
  pass
 def Write(self,pathToFile,renderContent,previewArgs):
  """
  Write(self: RenderContentSerializer,pathToFile: str,renderContent: RenderContent,previewArgs: CreatePreviewEventArgs) -> bool

  

   Called to save a custom RenderContent object as an external file.

  

   pathToFile: Full path of file to write

   renderContent: Render content to save

   previewArgs: Parameters used to generate a preview image which may be embedded in

     the exported 

    file.
  """
  pass
 @staticmethod
 def __new__(self,*args): #cannot find CLR constructor
  """ __new__(cls: type,fileExtension: str,contentKind: RenderContentKind,canRead: bool,canWrite: bool) """
  pass
 CanRead=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """If true then the file type can be imported and will be included in the

   file open box when importing the specified render content type.



Get: CanRead(self: RenderContentSerializer) -> bool



"""

 CanWrite=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """If true then the file type can be exported and will be included in the

   file save box when exporting the specified render content type.



Get: CanWrite(self: RenderContentSerializer) -> bool



"""

 ContentType=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Type of content created when importing or exporting this file type.



Get: ContentType(self: RenderContentSerializer) -> RenderContentKind



"""

 EnglishDescription=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """English string describing this plug-in



Get: EnglishDescription(self: RenderContentSerializer) -> str



"""

 FileExtension=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """File extension associated with this serialize object



Get: FileExtension(self: RenderContentSerializer) -> str



"""

 LocalDescription=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Localized plug-in description



Get: LocalDescription(self: RenderContentSerializer) -> str



"""



class RenderContentStyles(Enum,IComparable,IFormattable,IConvertible):
 """ enum (flags) RenderContentStyles,values: Adjustment (128),Fields (256),GraphDisplay (32),LocalTextureMapping (16),ModalEditing (512),None (0),PreviewCache (4),ProgressivePreview (8),QuickPreview (2),SharedUI (64),TextureSummary (1) """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Adjustment=None
 Fields=None
 GraphDisplay=None
 LocalTextureMapping=None
 ModalEditing=None
 None=None
 PreviewCache=None
 ProgressivePreview=None
 QuickPreview=None
 SharedUI=None
 TextureSummary=None
 value__=None


class RenderEndEventArgs(EventArgs):
 """
 Contains information about why OnRenderEnd was called

 

 RenderEndEventArgs()
 """

class RenderEnvironment(RenderContent,IDisposable):
 # no doc
 def Dispose(self):
  """ Dispose(self: RenderContent,disposing: bool) """
  pass
 def ModifyRenderContentStyles(self,*args):
  """ ModifyRenderContentStyles(self: RenderContent,stylesToAdd: RenderContentStyles,stylesToRemove: RenderContentStyles) """
  pass
 @staticmethod
 def NewBasicEnvironment(environment):
  """
  NewBasicEnvironment(environment: SimulatedEnvironment) -> RenderEnvironment

  

   Constructs a new Rhino.Render.RenderEnvironment from a Rhino.Render.SimulatedEnvironment.

  

   environment: The environment to create the basic environment from.

   Returns: A new basic environment.
  """
  pass
 def OnAddUserInterfaceSections(self,*args):
  """
  OnAddUserInterfaceSections(self: RenderContent)

   Override to provide UI sections to display in the editor.
  """
  pass
 def OnGetDefaultsInteractive(self,*args):
  """
  OnGetDefaultsInteractive(self: RenderContent,parentWindowHandle: IntPtr) -> bool

  

   Override this method to prompt user for information necessary to

     create a new 

    content object.  For example,if you are created a

     textured material you may prompt 

    the user for a bitmap file name

     prior to creating the textured material.

  

   Returns: If true is returned the content is created otherwise the creation

     is aborted.
  """
  pass
 def SimulateEnvironment(self,simualation,isForDataOnly):
  """ SimulateEnvironment(self: RenderEnvironment,simualation: SimulatedEnvironment,isForDataOnly: bool) -> SimulatedEnvironment """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass

class RenderEnvironmentTable(object,IEnumerable[RenderEnvironment],IEnumerable,IRhinoTable[RenderEnvironment]):
 # no doc
 def GetEnumerator(self):
  """ GetEnumerator(self: RenderEnvironmentTable) -> IEnumerator[RenderEnvironment] """
  pass
 def __contains__(self,*args):
  """ __contains__[RenderEnvironment](enumerable: IEnumerable[RenderEnvironment],value: RenderEnvironment) -> bool """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Count(self: RenderEnvironmentTable) -> int



"""

 Document=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Document(self: RenderEnvironmentTable) -> RhinoDoc



"""



class RenderMaterial(RenderContent,IDisposable):
 # no doc
 @staticmethod
 def CreateBasicMaterial(material):
  """
  CreateBasicMaterial(material: Material) -> RenderMaterial

  

   Constructs a new basic material from a Rhino.DocObjects.MaterialMaterial.

  

   material: (optional)The material to create the basic material from.

   Returns: A new basic material.
  """
  pass
 def Dispose(self):
  """ Dispose(self: RenderContent,disposing: bool) """
  pass
 def ModifyRenderContentStyles(self,*args):
  """ ModifyRenderContentStyles(self: RenderContent,stylesToAdd: RenderContentStyles,stylesToRemove: RenderContentStyles) """
  pass
 def OnAddUserInterfaceSections(self,*args):
  """
  OnAddUserInterfaceSections(self: RenderContent)

   Override to provide UI sections to display in the editor.
  """
  pass
 def OnGetDefaultsInteractive(self,*args):
  """
  OnGetDefaultsInteractive(self: RenderContent,parentWindowHandle: IntPtr) -> bool

  

   Override this method to prompt user for information necessary to

     create a new 

    content object.  For example,if you are created a

     textured material you may prompt 

    the user for a bitmap file name

     prior to creating the textured material.

  

   Returns: If true is returned the content is created otherwise the creation

     is aborted.
  """
  pass
 def SimulateMaterial(self,simulation,isForDataOnly):
  """
  SimulateMaterial(self: RenderMaterial,simulation: Material,isForDataOnly: bool) -> Material

  

   Override this function to provide a Rhino.DocObjects.Material definition for this material

    

     to be used by other rendering engines including the display.

  

  

   simulation: Set the properties of the input basic material to provide the simulation for this material.

   isForDataOnly: Called when only asking for a hash - don't write any textures to the disk - just provide the 

    filenames they will get.
  """
  pass
 def TextureChildSlotName(self,slot):
  """ TextureChildSlotName(self: RenderMaterial,slot: StandardChildSlots) -> str """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 DefaultPreviewBackgroundType=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Set or get the default scene background for the image that appears in

   preview panes



Get: DefaultPreviewBackgroundType(self: RenderMaterial) -> PreviewBackgroundType



Set: DefaultPreviewBackgroundType(self: RenderMaterial)=value

"""

 DefaultPreviewGeometryType=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Set or get the default geometry that appears in preview panes



Get: DefaultPreviewGeometryType(self: RenderMaterial) -> PreviewGeometryType



Set: DefaultPreviewGeometryType(self: RenderMaterial)=value

"""

 DefaultPreviewSize=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The default preview geometry size



Get: DefaultPreviewSize(self: RenderMaterial) -> float



Set: DefaultPreviewSize(self: RenderMaterial)=value

"""


 BasicMaterialParameterNames=None
 PreviewBackgroundType=None
 PreviewGeometryType=None
 StandardChildSlots=None


class RenderMaterialTable(object,IEnumerable[RenderMaterial],IEnumerable,IRhinoTable[RenderMaterial]):
 # no doc
 def GetEnumerator(self):
  """ GetEnumerator(self: RenderMaterialTable) -> IEnumerator[RenderMaterial] """
  pass
 def __contains__(self,*args):
  """ __contains__[RenderMaterial](enumerable: IEnumerable[RenderMaterial],value: RenderMaterial) -> bool """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Count(self: RenderMaterialTable) -> int



"""

 Document=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Document(self: RenderMaterialTable) -> RhinoDoc



"""



class RenderPanels(object):
 """ This class is used to extend the standard Render user interface """
 @staticmethod
 def FromRenderSessionId(plugIn,panelType,renderSessionId):
  """
  FromRenderSessionId(plugIn: PlugIn,panelType: Type,renderSessionId: Guid) -> object

  

   Get the instance of a render panel associated with a specific render

     session,this 

    is useful when it is necessary to update a control from a

     

    Rhino.Render.RenderPipeline

  

  

   plugIn: The plug-in that registered the custom user interface

   panelType: The type of panel to return

   renderSessionId: The Rhino.Render.RenderPipeline.RenderSessionId of a specific render

     session.

   Returns: Returns the custom panel object if found; otherwise null is returned.
  """
  pass
 def RegisterPanel(self,plugin,renderPanelType,panelType,caption,alwaysShow,initialShow):
  """
  RegisterPanel(self: RenderPanels,plugin: PlugIn,renderPanelType: RenderPanelType,panelType: Type,caption: str,alwaysShow: bool,initialShow: bool)

   Register custom render user interface with Rhino.  This should only be

     done in 

    Rhino.PlugIns.RenderPlugIn.RegisterRenderPanels(Rhino.Render.RenderPanels).  Panels

     

    registered after Rhino.PlugIns.RenderPlugIn.RegisterRenderPanels(Rhino.Render.RenderPanels) is 

    called

     will be ignored.

  

  

   plugin: The plug-in providing the custom user interface

   renderPanelType: See Rhino.Render.RenderPanelType for supported user interface types.

   panelType: The type of object to be created and added to the render container.

   caption: The caption for the custom user interface.

   alwaysShow: If true the custom user interface will always be visible,if false then

     it may be 

    hidden or shown as requested by the user.

  

   initialShow: Initial visibility state of the custom user interface control.
  """
  pass

class RenderPanelType(Enum,IComparable,IFormattable,IConvertible):
 """
 Contains the custom user interfaces that may be provided

 

 enum RenderPanelType,values: RenderWindow (0)
 """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 RenderWindow=None
 value__=None


class RenderPipeline(object,IDisposable):
 """
 Provides facilities to a render plug-in for integrating with the standard

    Rhino render window. Also adds helper functions for processing a render

    scene. This is the suggested class to use when integrating a renderer with

    Rhino and maintaining a "standard" user interface that users will expect.
 """
 def AddLightToScene(self,*args):
  """ AddLightToScene(self: RenderPipeline,light: LightObject) -> bool """
  pass
 def AddRenderMeshToScene(self,*args):
  """ AddRenderMeshToScene(self: RenderPipeline,obj: RhinoObject,material: Material,mesh: Mesh) -> bool """
  pass
 def CloseWindow(self):
  """
  CloseWindow(self: RenderPipeline) -> bool

  

   Closes the render window associated with this render instance.

   Returns: Return true if successful or false if not.
  """
  pass
 def CommandResult(self):
  """ CommandResult(self: RenderPipeline) -> Result """
  pass
 def ContinueModal(self,*args):
  """
  ContinueModal(self: RenderPipeline) -> bool

  

   Frequently called during a rendering by the frame work in order to

     determine if the 

    rendering should continue.

  

   Returns: Returns true if the rendering should continue.
  """
  pass
 def Dispose(self):
  """ Dispose(self: RenderPipeline) """
  pass
 def GetRenderWindow(self):
  """ GetRenderWindow(self: RenderPipeline) -> RenderWindow """
  pass
 def IgnoreRhinoObject(self,*args):
  """ IgnoreRhinoObject(self: RenderPipeline,obj: RhinoObject) -> bool """
  pass
 def NeedToProcessGeometryTable(self,*args):
  """ NeedToProcessGeometryTable(self: RenderPipeline) -> bool """
  pass
 def NeedToProcessLightTable(self,*args):
  """ NeedToProcessLightTable(self: RenderPipeline) -> bool """
  pass
 def OnRenderBegin(self,*args):
  """
  OnRenderBegin(self: RenderPipeline) -> bool

  

   Called by the framework when it is time to start rendering,the render window will be created at 

    this point and it is safe to start
  """
  pass
 def OnRenderEnd(self,*args):
  """
  OnRenderEnd(self: RenderPipeline,e: RenderEndEventArgs)

   Called by the framework when the user closes the render window or clicks

     on the 

    stop button in the render window.
  """
  pass
 def OnRenderWindowBegin(self,*args):
  """ OnRenderWindowBegin(self: RenderPipeline,view: RhinoView,rectangle: Rectangle) -> bool """
  pass
 def Render(self):
  """
  Render(self: RenderPipeline) -> RenderReturnCode

  

   Call this function to render the scene normally. The function returns when rendering is complete 

    (or cancelled).

  

   Returns: A code that explains how rendering completed.
  """
  pass
 def RenderEnterModalLoop(self,*args):
  """ RenderEnterModalLoop(self: RenderPipeline) -> bool """
  pass
 def RenderExitModalLoop(self,*args):
  """ RenderExitModalLoop(self: RenderPipeline) -> bool """
  pass
 def RenderPreCreateWindow(self,*args):
  """ RenderPreCreateWindow(self: RenderPipeline) -> bool """
  pass
 def RenderSceneWithNoMeshes(self,*args):
  """ RenderSceneWithNoMeshes(self: RenderPipeline) -> bool """
  pass
 @staticmethod
 def RenderSize():
  """
  RenderSize() -> Size

  

   Gets the render size as specified in the ON_3dmRenderSettings. Will automatically return the 

    correct size based on the ActiveView or custom settings.

  

   Returns: The render size.
  """
  pass
 def RenderWindow(self,view,rect,inWindow):
  """
  RenderWindow(self: RenderPipeline,view: RhinoView,rect: Rectangle,inWindow: bool) -> RenderReturnCode

  

   Call this function to render the scene in a view window. The function returns when rendering is 

    complete (or cancelled).

  

  

   view: the view that the user selected a rectangle in.

   rect: rectangle that the user selected.

   inWindow: true to render directly into the view window.

   Returns: A code that explains how rendering completed.
  """
  pass
 def SaveImage(self,fileName):
  """
  SaveImage(self: RenderPipeline,fileName: str) -> bool

  

   Saves the rendered image to a file.

  

   fileName: the full path to the file name to save to. If null or empty a file

     dialog will be 

    displayed prompting the user for a save file name.

  

   Returns: Returns true if a file was written or false if a file dialog was

     canceled or the 

    file was not written.
  """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 @staticmethod
 def __new__(self,*args): #cannot find CLR constructor
  """ __new__(cls: type,doc: RhinoDoc,mode: RunMode,plugin: PlugIn,sizeRendering: Size,caption: str,channels: StandardChannels,reuseRenderWindow: bool,clearLastRendering: bool) """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 ConfirmationSeconds=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Sets the number of seconds that need to elapse during rendering before the user is asked if the rendered image should be saved.



Set: ConfirmationSeconds(self: RenderPipeline)=value

"""

 PlugIn=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: PlugIn(self: RenderPipeline) -> PlugIn



"""

 RenderSessionId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get the Id associated with this render session,this is useful when

   looking up Rhino.Render.RenderPanels.



Get: RenderSessionId(self: RenderPipeline) -> Guid



"""


 RenderReturnCode=None


class RenderPrimitive(object,IDisposable):
 # no doc
 def Dispose(self):
  """ Dispose(self: RenderPrimitive) """
  pass
 def Mesh(self):
  """
  Mesh(self: RenderPrimitive) -> Mesh

  

   Returns the mesh associated with the object,this will mesh primitives

     and always 

    return a mesh.
  """
  pass
 def TryGetBox(self,box):
  """
  TryGetBox(self: RenderPrimitive) -> (bool,Box)

  

   Call this method to get a Rhino.Geometry.Box primitive for this mesh.  If this

     

    meshes Rhino.Render.RenderPrimitive.PrimitiveType is not a Rhino.Render.RenderPrimitiveType.Box

  

       then the box parameter is set to Rhino.Geometry.Box.Empty.

  

   Returns: Returns true if Rhino.Render.RenderPrimitive.PrimitiveType is 

    Rhino.Render.RenderPrimitiveType.Box and

     the box parameter was initialized 

    otherwise returns false.
  """
  pass
 def TryGetCone(self,cone,truncation):
  """
  TryGetCone(self: RenderPrimitive) -> (bool,Cone,Plane)

  

   Call this method to get a Rhino.Geometry.Cone primitive for this mesh.  If this

     

    meshes Rhino.Render.RenderPrimitive.PrimitiveType is not a Rhino.Render.RenderPrimitiveType.Cone


    
     then the cone parameter is set to Rhino.Geometry.Cone.Unset and the truncation

   

      parameter is set to Rhino.Geometry.Plane.Unset.

  

   Returns: Returns true if Rhino.Render.RenderPrimitive.PrimitiveType is 

    Rhino.Render.RenderPrimitiveType.Cone and

     the cone and truncation parameters were 

    initialized otherwise returns false.
  """
  pass
 def TryGetPlane(self,plane):
  """
  TryGetPlane(self: RenderPrimitive) -> (bool,PlaneSurface)

  

   Call this method to get a Rhino.Geometry.Plane primitive for this mesh.  If this

     

    meshes Rhino.Render.RenderPrimitive.PrimitiveType is not a 

    Rhino.Render.RenderPrimitiveType.Plane

     then the plane parameter is set to null.

  

   Returns: Returns true if Rhino.Render.RenderPrimitive.PrimitiveType is 

    Rhino.Render.RenderPrimitiveType.Plane and

     the plane parameter was initialized 

    otherwise returns false.
  """
  pass
 def TryGetSphere(self,sphere):
  """
  TryGetSphere(self: RenderPrimitive) -> (bool,Sphere)

  

   Call this method to get a sphere primitive for this mesh.  If this

     meshes 

    Rhino.Render.RenderPrimitive.PrimitiveType is not a Rhino.Render.RenderPrimitiveType.Sphere

   

      then the sphere parameter is set to Rhino.Geometry.Sphere.Unset.

  

   Returns: Returns true if Rhino.Render.RenderPrimitive.PrimitiveType is 

    Rhino.Render.RenderPrimitiveType.Sphere and

     the sphere parameter was initialized 

    otherwise returns false.
  """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 BoundingBox=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The bounding box for this primitive.



Get: BoundingBox(self: RenderPrimitive) -> BoundingBox



"""

 HasRenderMaterial=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """This property will be true if this mesh has a Rhino.Render.RenderPrimitive.RenderMaterial associated with

   it or false if there is a Rhino.Render.RenderPrimitive.Material.



Get: HasRenderMaterial(self: RenderPrimitive) -> bool



"""

 InstanceTransform=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Instance reference transform or Identity if not an instance reference.



Get: InstanceTransform(self: RenderPrimitive) -> Transform



"""

 Material=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The Rhino.Render.RenderPrimitive.Materialassociated with this mesh or null if the

   Rhino.Render.RenderPrimitive property has a value.



Get: Material(self: RenderPrimitive) -> Material



"""

 PrimitiveType=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Call this before extracting meshes if you support render primitives to

   get the Rhino.Render.RenderPrimitiveType of this mesh then call the

   associated Rhino.Render.RenderPrimitive.TryGetSphere(Rhino.Geometry.Sphere@),Rhino.Render.RenderPrimitive.TryGetPlane(Rhino.Geometry.PlaneSurface@),Rhino.Render.RenderPrimitive.TryGetCone(Rhino.Geometry.Cone@,Rhino.Geometry.Plane@),or

   Rhino.Render.RenderPrimitive.TryGetBox(Rhino.Geometry.Box@) method.  Calling the Rhino.Render.RenderPrimitive.Mesh property

   will mesh the primitive and return a mesh always.



Get: PrimitiveType(self: RenderPrimitive) -> RenderPrimitiveType



"""

 RenderMaterial=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The Rhino.Render.RenderPrimitive.RenderMaterial associated with this mesh or null if there is not one.



Get: RenderMaterial(self: RenderPrimitive) -> RenderMaterial



"""

 RhinoObject=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The Rhino object associated with this render primitive.



Get: RhinoObject(self: RenderPrimitive) -> RhinoObject



"""



class RenderPrimitiveList(object,IDisposable):
 # no doc
 def Add(self,*__args):
  """
  Add(self: RenderPrimitiveList,plane: PlaneSurface,material: RenderMaterial)

   Add primitive plane and material.

  

   plane: Plane to add.

   material: Material to add,may be null if not needed.

  Add(self: RenderPrimitiveList,box: Box,material: RenderMaterial)

   Add primitive box and material.

  

   box: Box to add.

   material: Material to add,may be null if not needed.

  Add(self: RenderPrimitiveList,cone: Cone,truncation: Plane,material: RenderMaterial)

   Add primitive cone and material.

  

   cone: Cone to add.

   truncation: The plane used to cut the cone (the non-apex end is kept). Should be

     equal to 

    cone.plane if not truncated.

  

   material: Material to add,may be null if not needed.

  Add(self: RenderPrimitiveList,mesh: Mesh,material: RenderMaterial)

   Add mesh and material.

  

   mesh: Mesh to add.

   material: Material to add,may be null if not needed.

  Add(self: RenderPrimitiveList,sphere: Sphere,material: RenderMaterial)

   Add primitive sphere and material.

  

   sphere: Sphere to add.

   material: Material to add,may be null if not needed.
  """
  pass
 def Clear(self):
  """
  Clear(self: RenderPrimitiveList)

   Remove all primitives from this list
  """
  pass
 def ConvertMeshesToTriangles(self):
  """
  ConvertMeshesToTriangles(self: RenderPrimitiveList)

   Convert mesh quad faces to triangle faces.
  """
  pass
 def Dispose(self):
  """ Dispose(self: RenderPrimitiveList) """
  pass
 def Material(self,index):
  """
  Material(self: RenderPrimitiveList,index: int) -> RenderMaterial

  

   Call this method to get the render material associated with the mesh at

     the 

    specified index.  Will return null if there is no

     material associated with the 

    requested mesh.

  

  

   index: The zero based index of the item in the list.  Valid values are greater

     than or 

    equal to 0 and less than Count.

  

   Returns: If there is a render material associated at the requested index then

     the material 

    is returned otherwise null is returned.
  """
  pass
 def Mesh(self,index):
  """
  Mesh(self: RenderPrimitiveList,index: int) -> Mesh

  

   Get the mesh for the primitive at the specified index. If the item at

     this index is 

    a primitive type other than a mesh then it mesh

     representation is returned.

  

  

   index: The zero based index of the item in the list.  Valid values are greater

     than or 

    equal to 0 and less than Count.

  

   Returns: Returns the mesh for the primitive at the specified index. If the item

     at this 

    index is a primitive type other than a mesh then it mesh

     representation is 

    returned.
  """
  pass
 def PrimitiveType(self,index):
  """
  PrimitiveType(self: RenderPrimitiveList,index: int) -> RenderPrimitiveType

  

   Type of primitive object at this index.

  

   index: The zero based index of the item in the list.  Valid values are greater

     than or 

    equal to 0 and less than Count.

  

   Returns: Primitive type of the item at this index.
  """
  pass
 def ToMaterialArray(self):
  """
  ToMaterialArray(self: RenderPrimitiveList) -> Array[RenderMaterial]

  

   Call this method to see if there are any RenderMaterials associated

     with the 

    meshes.  Each primitive can optionally have a RenderMaterial

     associated with it,if 

    the RenderMaterial is null then check for a

     RhinoObject.RenderMaterial.

  

   Returns: Return an array that of the same size as the ToMeshArray() containing

     the 

    RenderMaterial associated with the mesh,may contain null entries

     if there is no 

    RenderMaterial associated with the custom mesh.
  """
  pass
 def ToMeshArray(self):
  """
  ToMeshArray(self: RenderPrimitiveList) -> Array[Mesh]

  

   Call this method to get a array of meshes,all primitives will get

     meshed and the 

    meshes will get included in the returned array.

  

   Returns: Return an array of meshes from this list,this will convert all

     primitives to 

    meshes.
  """
  pass
 def TryGetBox(self,index,box):
  """
  TryGetBox(self: RenderPrimitiveList,index: int) -> (bool,Box)

  

   Call this method to get a box at the specified index.

  

   index: The zero based index of the item in the list.  Valid values are greater

     than or 

    equal to 0 and less than Count.

  

   Returns: Return true if the index is in range and the primitive at the requested

     index is a 

    box otherwise returns false.
  """
  pass
 def TryGetCone(self,index,cone,truncation):
  """
  TryGetCone(self: RenderPrimitiveList,index: int) -> (bool,Cone,Plane)

  

   Call this method to get a box at the specified index.

  

   index: The zero based index of the item in the list.  Valid values are greater

     than or 

    equal to 0 and less than Count.

  

   Returns: Return true if the index is in range and the primitive at the requested

     index is a 

    box otherwise returns false.
  """
  pass
 def TryGetPlane(self,index,plane):
  """
  TryGetPlane(self: RenderPrimitiveList,index: int) -> (bool,PlaneSurface)

  

   Call this method to get a box at the specified index.

  

   index: The zero based index of the item in the list.  Valid values are greater

     than or 

    equal to 0 and less than Count.

  

   Returns: Return true if the index is in range and the primitive at the requested

     index is a 

    plane otherwise returns false.
  """
  pass
 def TryGetSphere(self,index,sphere):
  """
  TryGetSphere(self: RenderPrimitiveList,index: int) -> (bool,Sphere)

  

   Call this method to get a box at the specified index.

  

   index: The zero based index of the item in the list.  Valid values are greater

     than or 

    equal to 0 and less than Count.

  

   Returns: Return true if the index is in range and the primitive at the requested

     index is a 

    box otherwise returns false.
  """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+yx.__add__(y) <==> x+yx.__add__(y) <==> x+yx.__add__(y) <==> x+yx.__add__(y) <==> x+y """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Number of meshes in this list



Get: Count(self: RenderPrimitiveList) -> int



"""

 RhinoObject=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The Rhino object associated with this list



Get: RhinoObject(self: RenderPrimitiveList) -> RhinoObject



"""

 UseObjectsMappingChannels=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Returns true if the texture mapping will be taken from the Rhino

   object otherwise; the texture mapping will use the texture coordinates

   on the mesh only.



Get: UseObjectsMappingChannels(self: RenderPrimitiveList) -> bool



Set: UseObjectsMappingChannels(self: RenderPrimitiveList)=value

"""



class RenderPrimitiveType(Enum,IComparable,IFormattable,IConvertible):
 """ enum RenderPrimitiveType,values: Box (4),Cone (5),Mesh (1),None (0),Plane (3),Sphere (2) """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Box=None
 Cone=None
 Mesh=None
 None=None
 Plane=None
 Sphere=None
 value__=None


class RenderPropertyChangedEvent(EventArgs):
 """ Used by Rhino.Render object property value has changed events. """
 Context=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Optional argument which may specify the property being modified.



Get: Context(self: RenderPropertyChangedEvent) -> int



"""

 Document=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The document triggering the event.



Get: Document(self: RenderPropertyChangedEvent) -> RhinoDoc



"""



class RenderSettings(object,IDisposable):
 """
 Contains settings used in rendering.

 

 RenderSettings()
 """
 def Dispose(self):
  """
  Dispose(self: RenderSettings)

   Actively reclaims unmanaged resources that this instance uses.
  """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 AmbientLight=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the ambient light color used in rendering.



Get: AmbientLight(self: RenderSettings) -> Color



Set: AmbientLight(self: RenderSettings)=value

"""

 AntialiasLevel=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """0=none,1=normal,2=best.



Get: AntialiasLevel(self: RenderSettings) -> int



Set: AntialiasLevel(self: RenderSettings)=value

"""

 BackgroundColorBottom=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the background bottom color used in rendering.



Get: BackgroundColorBottom(self: RenderSettings) -> Color



Set: BackgroundColorBottom(self: RenderSettings)=value

"""

 BackgroundColorTop=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the background top color used in rendering.

   Sets also the background color if a solid background color is set.



Get: BackgroundColorTop(self: RenderSettings) -> Color



Set: BackgroundColorTop(self: RenderSettings)=value

"""

 BackgroundStyle=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """How the viewport's backgroun should be filled.



Get: BackgroundStyle(self: RenderSettings) -> BackgroundStyle



Set: BackgroundStyle(self: RenderSettings)=value

"""

 DepthCue=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to render using depth cues.

   These are clues to help the perception of position and orientation of objects in the image.



Get: DepthCue(self: RenderSettings) -> bool



Set: DepthCue(self: RenderSettings)=value

"""

 FlatShade=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to render using flat shading.



Get: FlatShade(self: RenderSettings) -> bool



Set: FlatShade(self: RenderSettings)=value

"""

 ImageDpi=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Number of dots/inch (dots=pixels) to use when printing and saving

   bitmaps. The default is 72.0 dots/inch.



Get: ImageDpi(self: RenderSettings) -> float



Set: ImageDpi(self: RenderSettings)=value

"""

 ImageSize=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating the size of the rendering result if

   UseViewportSize is set to false.  If UseViewportSize is set to true,

   then this value is ignored.



Get: ImageSize(self: RenderSettings) -> Size



Set: ImageSize(self: RenderSettings)=value

"""

 ImageUnitSystem=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """unit system to use when converting image pixel size and dpi information

   into a print size.  Default=inches



Get: ImageUnitSystem(self: RenderSettings) -> UnitSystem



Set: ImageUnitSystem(self: RenderSettings)=value

"""

 RenderAnnotations=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to instruct the rendering engine to show annotations,

   such as linear dimensions or angular dimensions.



Get: RenderAnnotations(self: RenderSettings) -> bool



Set: RenderAnnotations(self: RenderSettings)=value

"""

 RenderBackfaces=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to render back faces.



Get: RenderBackfaces(self: RenderSettings) -> bool



Set: RenderBackfaces(self: RenderSettings)=value

"""

 RenderCurves=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to instruct the rendering engine to show curves.



Get: RenderCurves(self: RenderSettings) -> bool



Set: RenderCurves(self: RenderSettings)=value

"""

 RenderIsoparams=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to instruct the rendering engine to show isocurves.



Get: RenderIsoparams(self: RenderSettings) -> bool



Set: RenderIsoparams(self: RenderSettings)=value

"""

 RenderMeshEdges=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to instruct the rendering engine to show mesh edges.



Get: RenderMeshEdges(self: RenderSettings) -> bool



Set: RenderMeshEdges(self: RenderSettings)=value

"""

 RenderPoints=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to instruct the rendering engine to show points.



Get: RenderPoints(self: RenderSettings) -> bool



Set: RenderPoints(self: RenderSettings)=value

"""

 ShadowmapLevel=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """0=none,1=normal,2=best.



Get: ShadowmapLevel(self: RenderSettings) -> int



Set: ShadowmapLevel(self: RenderSettings)=value

"""

 UseHiddenLights=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to render using lights that are on layers that are off.



Get: UseHiddenLights(self: RenderSettings) -> bool



Set: UseHiddenLights(self: RenderSettings)=value

"""

 UseViewportSize=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value indicating whether to use the resolution of the

   viewport being rendered or ImageSize when rendering



Get: UseViewportSize(self: RenderSettings) -> bool



Set: UseViewportSize(self: RenderSettings)=value

"""



class RenderTabs(object):
 # no doc
 @staticmethod
 def FromRenderSessionId(plugIn,tabType,renderSessionId):
  """
  FromRenderSessionId(plugIn: PlugIn,tabType: Type,renderSessionId: Guid) -> object

  

   Get the instance of a render tab associated with a specific render

     session,this is 

    useful when it is necessary to update a control from a

     Rhino.Render.RenderPipeline

  

  

   plugIn: The plug-in that registered the custom user interface

   tabType: The type of tab to return

   renderSessionId: The Rhino.Render.RenderPipeline.RenderSessionId of a specific render

     session.

   Returns: Returns the custom tab object if found; otherwise null is returned.
  """
  pass
 def RegisterTab(self,plugin,tabType,caption,icon):
  """
  RegisterTab(self: RenderTabs,plugin: PlugIn,tabType: Type,caption: str,icon: Icon)

   Register custom render user interface with Rhino.  This should only be

     done in 

    Rhino.PlugIns.RenderPlugIn.RegisterRenderPanels(Rhino.Render.RenderPanels).  Panels

     

    registered after Rhino.PlugIns.RenderPlugIn.RegisterRenderPanels(Rhino.Render.RenderPanels) is 

    called

     will be ignored.

  

  

   plugin: The plug-in providing the custom user interface

   tabType: The type of object to be created and added to the render container.

   caption: The caption for the custom user interface.
  """
  pass
 @staticmethod
 def SessionIdFromTab(tab):
  """
  SessionIdFromTab(tab: object) -> Guid

  

   Get the session Id that created the specified tab object.
  """
  pass

class RenderTexture(RenderContent,IDisposable):
 # no doc
 def CreateEvaluator(self):
  """
  CreateEvaluator(self: RenderTexture) -> TextureEvaluator

  

   Constructs a texture evaluator. This is an independent lightweight object

     capable 

    of evaluating texture color throughout uvw space. May be called

     from within a 

    rendering shade pipeline.

  

   Returns: A texture evaluator instance.
  """
  pass
 def Dispose(self):
  """ Dispose(self: RenderContent,disposing: bool) """
  pass
 def GetDisplayInViewport(self):
  """ GetDisplayInViewport(self: RenderTexture) -> bool """
  pass
 def GetEnvironmentMappingMode(self):
  """ GetEnvironmentMappingMode(self: RenderTexture) -> TextureEnvironmentMappingMode """
  pass
 @staticmethod
 def GetEnvironmentMappingProjection(mode,reflectionVector,u,v):
  """ GetEnvironmentMappingProjection(mode: TextureEnvironmentMappingMode,reflectionVector: Vector3d) -> (bool,Single,Single) """
  pass
 def GetInternalEnvironmentMappingMode(self):
  """ GetInternalEnvironmentMappingMode(self: RenderTexture) -> TextureEnvironmentMappingMode """
  pass
 def GetMappingChannel(self):
  """ GetMappingChannel(self: RenderTexture) -> int """
  pass
 def GetOffset(self):
  """
  GetOffset(self: RenderTexture) -> Vector3d

  

   Get offset value across UVW space. If the projection type is WCS or

     other type 

    specified in model units,then this is the offset in meters.
  """
  pass
 def GetOffsetLocked(self):
  """ GetOffsetLocked(self: RenderTexture) -> bool """
  pass
 def GetPreviewIn3D(self):
  """ GetPreviewIn3D(self: RenderTexture) -> bool """
  pass
 def GetPreviewLocalMapping(self):
  """ GetPreviewLocalMapping(self: RenderTexture) -> bool """
  pass
 def GetProjectionMode(self):
  """ GetProjectionMode(self: RenderTexture) -> TextureProjectionMode """
  pass
 def GetRepeat(self):
  """
  GetRepeat(self: RenderTexture) -> Vector3d

  

   Get repeat value across UVW space. If the projection type is WCS or

     other type 

    specified in model units,then this is the repeat across 1

     meter of the model.
  """
  pass
 def GetRepeatLocked(self):
  """ GetRepeatLocked(self: RenderTexture) -> bool """
  pass
 def GetRotation(self):
  """ GetRotation(self: RenderTexture) -> Vector3d """
  pass
 @staticmethod
 def GetWcsBoxMapping(worldXyz,normal):
  """ GetWcsBoxMapping(worldXyz: Point3d,normal: Vector3d) -> Point3d """
  pass
 def GetWrapType(self):
  """ GetWrapType(self: RenderTexture) -> TextureWrapType """
  pass
 def IsHdrCapable(self):
  """ IsHdrCapable(self: RenderTexture) -> bool """
  pass
 def ModifyRenderContentStyles(self,*args):
  """ ModifyRenderContentStyles(self: RenderContent,stylesToAdd: RenderContentStyles,stylesToRemove: RenderContentStyles) """
  pass
 @staticmethod
 def NewBitmapTexture(texture):
  """
  NewBitmapTexture(texture: SimulatedTexture) -> RenderTexture

  

   Constructs a new basic texture from a SimulatedTexture.

  

   texture: The texture to create the basic texture from.

   Returns: A new render texture.
  """
  pass
 def OnAddUserInterfaceSections(self,*args):
  """
  OnAddUserInterfaceSections(self: RenderContent)

   Override to provide UI sections to display in the editor.
  """
  pass
 def OnGetDefaultsInteractive(self,*args):
  """
  OnGetDefaultsInteractive(self: RenderContent,parentWindowHandle: IntPtr) -> bool

  

   Override this method to prompt user for information necessary to

     create a new 

    content object.  For example,if you are created a

     textured material you may prompt 

    the user for a bitmap file name

     prior to creating the textured material.

  

   Returns: If true is returned the content is created otherwise the creation

     is aborted.
  """
  pass
 def SetDisplayInViewport(self,value,changeContext):
  """ SetDisplayInViewport(self: RenderTexture,value: bool,changeContext: ChangeContexts) """
  pass
 def SetEnvironmentMappingMode(self,value,changeContext):
  """ SetEnvironmentMappingMode(self: RenderTexture,value: TextureEnvironmentMappingMode,changeContext: ChangeContexts) """
  pass
 def SetMappingChannel(self,value,changeContext):
  """ SetMappingChannel(self: RenderTexture,value: int,changeContext: ChangeContexts) """
  pass
 def SetOffset(self,value,changeContext):
  """ SetOffset(self: RenderTexture,value: Vector3d,changeContext: ChangeContexts) """
  pass
 def SetOffsetLocked(self,value,changeContext):
  """ SetOffsetLocked(self: RenderTexture,value: bool,changeContext: ChangeContexts) """
  pass
 def SetPreviewIn3D(self,value,changeContext):
  """ SetPreviewIn3D(self: RenderTexture,value: bool,changeContext: ChangeContexts) """
  pass
 def SetPreviewLocalMapping(self,value,changeContext):
  """ SetPreviewLocalMapping(self: RenderTexture,value: bool,changeContext: ChangeContexts) """
  pass
 def SetProjectionMode(self,value,changeContext):
  """ SetProjectionMode(self: RenderTexture,value: TextureProjectionMode,changeContext: ChangeContexts) """
  pass
 def SetRepeat(self,value,changeContext):
  """ SetRepeat(self: RenderTexture,value: Vector3d,changeContext: ChangeContexts) """
  pass
 def SetRepeatLocked(self,value,changeContext):
  """ SetRepeatLocked(self: RenderTexture,value: bool,changeContext: ChangeContexts) """
  pass
 def SetRotation(self,value,changeContext):
  """ SetRotation(self: RenderTexture,value: Vector3d,changeContext: ChangeContexts) """
  pass
 def SetWrapType(self,value,changeContext):
  """ SetWrapType(self: RenderTexture,value: TextureWrapType,changeContext: ChangeContexts) """
  pass
 def SimulateTexture(self,simulation,isForDataOnly):
  """ SimulateTexture(self: RenderTexture,simulation: SimulatedTexture,isForDataOnly: bool) -> SimulatedTexture """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 LocalMappingTransform=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the transformation that can be applied to the UVW vector to convert it

   from normalized texture space into locally mapped space (ie - with repeat,

   offset and rotation applied.)



Get: LocalMappingTransform(self: RenderTexture) -> Transform



"""



class RenderTextureTable(object,IEnumerable[RenderTexture],IEnumerable,IRhinoTable[RenderTexture]):
 # no doc
 def GetEnumerator(self):
  """ GetEnumerator(self: RenderTextureTable) -> IEnumerator[RenderTexture] """
  pass
 def __contains__(self,*args):
  """ __contains__[RenderTexture](enumerable: IEnumerable[RenderTexture],value: RenderTexture) -> bool """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Count(self: RenderTextureTable) -> int



"""

 Document=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Document(self: RenderTextureTable) -> RhinoDoc



"""



class RenderWindow(object):
 # no doc
 def AddChannel(self,channel):
  """ AddChannel(self: RenderWindow,channel: StandardChannels) -> bool """
  pass
 def AddWireframeChannel(self,doc,viewport,size,region):
  """
  AddWireframeChannel(self: RenderWindow,doc: RhinoDoc,viewport: ViewportInfo,size: Size,region: Rectangle) -> bool

  

   A wireframe channel will not be added if none of the document properties settings

     

    indicate that one is needed. In other words,Rhino will not generate an empty wireframe channel

  

       just for the fun of it.

  

  

   doc: The document to display

   viewport: The view to display

   size: The size of the image without clipping (ie - if you have a region,it was the

     size 

    of the image before you cut the region out.

  

   region: The area of the rendering you want to display.  This should match the size

     of the 

    render window itself (ie - the one set using SetSize)

  

   Returns: Returns true if the wireframe channel was successfully added.
  """
  pass
 @staticmethod
 def ChannelId(ch):
  """ ChannelId(ch: StandardChannels) -> Guid """
  pass
 @staticmethod
 def FromSessionId(sessionId):
  """ FromSessionId(sessionId: Guid) -> RenderWindow """
  pass
 def Invalidate(self):
  """
  Invalidate(self: RenderWindow)

   Invalidate the entire view window so that the pixels get painted.
  """
  pass
 def InvalidateArea(self,rect):
  """ InvalidateArea(self: RenderWindow,rect: Rectangle) """
  pass
 def OpenChannel(self,id):
  """ OpenChannel(self: RenderWindow,id: StandardChannels) -> Channel """
  pass
 def SetProgress(self,text,progress):
  """
  SetProgress(self: RenderWindow,text: str,progress: Single)

   Accepts a rendering progress value to inform the user of the rendering advances.

  

   text: The progress text.

   progress: A progress value in the domain [0.0f; 1.0f].
  """
  pass
 def SetRGBAChannelColors(self,*__args):
  """
  SetRGBAChannelColors(self: RenderWindow,rectangle: Rectangle,colors: Array[Color4f])

   Call this method to open the RenderWindow.StandardChannels.RGBA channel and set a block of color 

    values

  

  

   rectangle: rectangle.X is the horizontal pixel position of the left edge. No validation is done on this 

    value.

       The caller is responsible for ensuring that it is within the frame buffer.


    
     rectangle.Y is the vertical pixel position of the top edge. No validation is done 

    on this value.

       The caller is responsible for ensuring that it is within the frame 

    buffer.

     rectangle.Width is the width of the rectangle in pixels. No validation is 

    done on this value.

     rectangle.Height is the height of the rectangle in pixels. No 

    validation is done on this value.

  

   colors: Array of Color4f values used to set the RenderWindow.StandardChannels.RGBA

  SetRGBAChannelColors(self: RenderWindow,size: Size,colors: Array[Color4f])

   Call this method to open the RenderWindow.StandardChannels.RGBA channel and set a block of color 

    values

  

  

   size: Size of the area to set. No validation is done on this value

   colors: Array of Color4f values used to set the RenderWindow.StandardChannels.RGBA
  """
  pass
 def SetSize(self,size):
  """ SetSize(self: RenderWindow,size: Size) """
  pass
 def Size(self):
  """ Size(self: RenderWindow) -> Size """
  pass
 SessionId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: SessionId(self: RenderWindow) -> Guid



"""


 Channel=None
 Cloned=None
 StandardChannels=None


class RenderWindowClonedEventArgs(EventArgs):
 # no doc
 NewRenderWindow=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: NewRenderWindow(self: RenderWindowClonedEventArgs) -> RenderWindow



"""

 NewSessionId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: NewSessionId(self: RenderWindowClonedEventArgs) -> Guid



"""

 OldRenderWindow=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: OldRenderWindow(self: RenderWindowClonedEventArgs) -> RenderWindow



"""

 OldSessionId=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: OldSessionId(self: RenderWindowClonedEventArgs) -> Guid



"""



class SimulatedEnvironment(object,IDisposable):
 """ SimulatedEnvironment() """
 def ConstPointer(self):
  """ ConstPointer(self: SimulatedEnvironment) -> IntPtr """
  pass
 def Dispose(self):
  """ Dispose(self: SimulatedEnvironment) """
  pass
 @staticmethod
 def ProjectionFromString(projection):
  """ ProjectionFromString(projection: str) -> BackgroundProjections """
  pass
 @staticmethod
 def StringFromProjection(projection):
  """ StringFromProjection(projection: BackgroundProjections) -> str """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 BackgroundColor=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: BackgroundColor(self: SimulatedEnvironment) -> Color



Set: BackgroundColor(self: SimulatedEnvironment)=value

"""

 BackgroundImage=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: BackgroundImage(self: SimulatedEnvironment) -> SimulatedTexture



Set: BackgroundImage(self: SimulatedEnvironment)=value

"""

 BackgroundProjection=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: BackgroundProjection(self: SimulatedEnvironment) -> BackgroundProjections



Set: BackgroundProjection(self: SimulatedEnvironment)=value

"""


 BackgroundProjections=None


class SimulatedTexture(object,IDisposable):
 """ SimulatedTexture() """
 def ConstPointer(self):
  """ ConstPointer(self: SimulatedTexture) -> IntPtr """
  pass
 def Dispose(self):
  """ Dispose(self: SimulatedTexture) """
  pass
 def MetersToUnits(self,units):
  """ MetersToUnits(self: SimulatedTexture,units: float) -> float """
  pass
 def Texture(self):
  """ Texture(self: SimulatedTexture) -> Texture """
  pass
 def UnitsToMeters(self,units):
  """ UnitsToMeters(self: SimulatedTexture,units: float) -> float """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Filename=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Filename(self: SimulatedTexture) -> str



Set: Filename(self: SimulatedTexture)=value

"""

 Filtered=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Filtered(self: SimulatedTexture) -> bool



Set: Filtered(self: SimulatedTexture)=value

"""

 HasTransparentColor=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: HasTransparentColor(self: SimulatedTexture) -> bool



Set: HasTransparentColor(self: SimulatedTexture)=value

"""

 LocalMappingTransform=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: LocalMappingTransform(self: SimulatedTexture) -> Transform



"""

 MappingChannel=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: MappingChannel(self: SimulatedTexture) -> int



Set: MappingChannel(self: SimulatedTexture)=value

"""

 Offset=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Offset(self: SimulatedTexture) -> Vector2d



Set: Offset(self: SimulatedTexture)=value

"""

 OriginalFilename=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: OriginalFilename(self: SimulatedTexture) -> str



"""

 ProjectionMode=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: ProjectionMode(self: SimulatedTexture) -> ProjectionModes



Set: ProjectionMode(self: SimulatedTexture)=value

"""

 Repeat=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Repeat(self: SimulatedTexture) -> Vector2d



Set: Repeat(self: SimulatedTexture)=value

"""

 Repeating=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Repeating(self: SimulatedTexture) -> bool



Set: Repeating(self: SimulatedTexture)=value

"""

 Rotation=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Rotation(self: SimulatedTexture) -> float



Set: Rotation(self: SimulatedTexture)=value

"""

 TransparentColor=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: TransparentColor(self: SimulatedTexture) -> Color4f



Set: TransparentColor(self: SimulatedTexture)=value

"""

 TransparentColorSensitivity=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: TransparentColorSensitivity(self: SimulatedTexture) -> float



Set: TransparentColorSensitivity(self: SimulatedTexture)=value

"""


 ProjectionModes=None


class Sun(object,IDisposable):
 """
 Represents the Sun on a little portion of Earth.

 

 Sun()
 """
 def Dispose(self):
  """ Dispose(self: Sun) """
  pass
 def GetDateTime(self,kind):
  """ GetDateTime(self: Sun,kind: DateTimeKind) -> DateTime """
  pass
 def SetPosition(self,*__args):
  """
  SetPosition(self: Sun,when: DateTime,latitudeDegrees: float,longitudeDegrees: float)

   Sets position of the sun based on physical location and time.

  

   when: A datetime instance.

     If the date System.DateTime.KindKind is 

    System.DateTimeKind.LocalDateTimeKind.Local,

     or 

    System.DateTimeKind.UnspecifiedDateTimeKind.Unspecified,the date is considered local.

  

   latitudeDegrees: The latitude,in degrees,of the location on Earth.

   longitudeDegrees: The longitude,in degrees,of the location on Earth.

  SetPosition(self: Sun,azimuthDegrees: float,altitudeDegrees: float)

   Sets position of the Sun based on azimuth and altitude values.

  

   azimuthDegrees: The azimut sun angle in degrees.

   altitudeDegrees: The altitude sun angle in degrees.
  """
  pass
 def ShowDialog(self):
  """
  ShowDialog(self: Sun)

   Show the tabbed sun dialog.
  """
  pass
 @staticmethod
 def SunDirection(latitude,longitude,when):
  """ SunDirection(latitude: float,longitude: float,when: DateTime) -> Vector3d """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Altitude=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Altitude(self: Sun) -> float



"""

 Azimuth=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Azimuth(self: Sun) -> float



"""

 DaylightSaving=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Daylight savings time



Get: DaylightSaving(self: Sun) -> bool



Set: DaylightSaving(self: Sun)=value

"""

 Enabled=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Turn to sun on/off in this document.



Get: Enabled(self: Sun) -> bool



Set: Enabled(self: Sun)=value

"""

 Latitude=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Latitude(self: Sun) -> float



"""

 Longitude=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Longitude(self: Sun) -> float



"""

 ManualControl=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Set angles directly or use place/date/time



Get: ManualControl(self: Sun) -> bool



Set: ManualControl(self: Sun)=value

"""

 North=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Angle in degrees on world X-Y plane that should be considered north in the model. Angle is

   measured starting at X-Axis and travels counterclockwise. Y-Axis would be a north angle of 90

   degrees.



Get: North(self: Sun) -> float



Set: North(self: Sun)=value

"""

 SkylightOn=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Turn skylight on or off



Get: SkylightOn(self: Sun) -> bool



Set: SkylightOn(self: Sun)=value

"""

 TimeZone=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Measured in hours += UTC



Get: TimeZone(self: Sun) -> float



Set: TimeZone(self: Sun)=value

"""

 Vector=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Vector(self: Sun) -> Vector3d



"""


 Changed=None


class TextureEnvironmentMappingMode(Enum,IComparable,IFormattable,IConvertible):
 """ enum TextureEnvironmentMappingMode,values: Automatic (0),Box (3),Cube (6),EnvironmentMap (2),Hemispherical (9),HorizontalCrossCube (8),LightProbe (5),Spherical (1),VerticalCrossCube (7) """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Automatic=None
 Box=None
 Cube=None
 EnvironmentMap=None
 Hemispherical=None
 HorizontalCrossCube=None
 LightProbe=None
 Spherical=None
 value__=None
 VerticalCrossCube=None


class TextureEvaluator(object,IDisposable):
 # no doc
 def Dispose(self):
  """ Dispose(self: TextureEvaluator) """
  pass
 def GetColor(self,uvw,duvwdx,duvwdy):
  """ GetColor(self: TextureEvaluator,uvw: Point3d,duvwdx: Vector3d,duvwdy: Vector3d) -> Color4f """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass

class TextureMapping(CommonObject,IDisposable,ISerializable):
 """ Represents a texture mapping. """
 def ConstructConstObject(self,*args):
  """
  ConstructConstObject(self: CommonObject,parentObject: object,subobject_index: int)

   Assigns a parent object and a subobject index to this.

  

   parentObject: The parent object.

   subobject_index: The subobject index.
  """
  pass
 @staticmethod
 def CreateBoxMapping(plane,dx,dy,dz,capped):
  """
  CreateBoxMapping(plane: Plane,dx: Interval,dy: Interval,dz: Interval,capped: bool) -> TextureMapping

  

   Create a box projection texture mapping.

  

   plane: The sides of the box the box are parallel to the plane's coordinate

     planes.  The 

    dx,dy,dz intervals determine the location of the sides.

  

   dx: Determines the location of the front and back planes. The vector

     plane.xaxis is 

    perpendicular to these planes and they pass through

     plane.PointAt(dx[0],0,0) and 

    plane.PointAt(dx[1],0,0),respectivly.

  

   dy: Determines the location of the left and right planes. The vector

     plane.yaxis is 

    perpendicular to these planes and they pass through

     plane.PointAt(0,dy[0],0) and 

    plane.PointAt(0,dy[1],0),respectivly.

  

   dz: Determines the location of the top and bottom planes. The vector

     plane.zaxis is 

    perpendicular to these planes and they pass through

     plane.PointAt(0,0,dz[0]) and 

    plane.PointAt(0,0,dz[1]),respectivly.

  

   capped: If true,the box is treated as a finite capped box.

   Returns: TextureMapping instance if input is valid
  """
  pass
 @staticmethod
 def CreateCylinderMapping(cylinder,capped):
  """
  CreateCylinderMapping(cylinder: Cylinder,capped: bool) -> TextureMapping

  

   Create a cylindrical projection texture mapping.

  

   cylinder: cylinder in world space used to define a cylindrical coordinate system.

     The angular 

    parameter maps (0,2pi) to texture "u" (0,1),The height

     parameter maps 

    (height[0],height[1]) to texture "v" (0,1),and the

     radial parameter maps (0,r) to 

    texture "w" (0,1).

  

   capped: If true,the cylinder is treated as a finite capped cylinder

   Returns: TextureMapping instance if input is valid
  """
  pass
 @staticmethod
 def CreatePlaneMapping(plane,dx,dy,dz):
  """
  CreatePlaneMapping(plane: Plane,dx: Interval,dy: Interval,dz: Interval) -> TextureMapping

  

   Create a planar projection texture mapping

  

   plane: A plane to use for mapping.

   dx: portion of the plane's x axis that is mapped to [0,1] (can be a decreasing interval)

   dy: portion of the plane's y axis that is mapped to [0,1] (can be a decreasing interval)

   dz: portion of the plane's z axis that is mapped to [0,1] (can be a decreasing interval)

   Returns: TextureMapping instance if input is valid
  """
  pass
 @staticmethod
 def CreateSphereMapping(sphere):
  """
  CreateSphereMapping(sphere: Sphere) -> TextureMapping

  

   Create a spherical projection texture mapping.

  

   sphere: sphere in world space used to define a spherical coordinate system.

     The longitude 

    parameter maps (0,2pi) to texture "u" (0,1).

     The latitude paramter maps 

    (-pi/2,+pi/2) to texture "v" (0,1).

     The radial parameter maps (0,r) to texture "w" 

    (0,1).

  

   Returns: TextureMapping instance if input is valid
  """
  pass
 def Dispose(self):
  """
  Dispose(self: CommonObject,disposing: bool)

   For derived class implementers.

     This method is called with argument true when class 

    user calls Dispose(),while with argument false when

     the Garbage Collector invokes 

    the finalizer,or Finalize() method.You must reclaim all used unmanaged resources in both cases,

    and can use this chance to call Dispose on disposable fields if the argument is true.Also,you 

    must call the base virtual method within your overriding method.

  

  

   disposing: true if the call comes from the Dispose() method; false if it comes from the Garbage Collector 

    finalizer.
  """
  pass
 def NonConstOperation(self,*args):
  """
  NonConstOperation(self: CommonObject)

   For derived classes implementers.

     Defines the necessary implementation to free the 

    instance from being const.
  """
  pass
 def OnSwitchToNonConst(self,*args):
  """
  OnSwitchToNonConst(self: CommonObject)

   Is called when a non-const operation first occurs.
  """
  pass
 def TryGetMappingBox(self,plane,dx,dy,dz):
  """
  TryGetMappingBox(self: TextureMapping) -> (bool,Plane,Interval,Interval,Interval)

  

   Get a box projection from the texture mapping.

   Returns: Returns true if a valid box is returned.
  """
  pass
 def TryGetMappingCylinder(self,cylinder):
  """
  TryGetMappingCylinder(self: TextureMapping) -> (bool,Cylinder)

  

   Get a cylindrical projection parameters from this texture mapping.

   Returns: Returns true if a valid cylinder is returned.
  """
  pass
 def TryGetMappingPlane(self,plane,dx,dy,dz):
  """
  TryGetMappingPlane(self: TextureMapping) -> (bool,Plane,Interval,Interval,Interval)

  

   Get plane mapping parameters from this texture mapping.

   Returns: Return true if valid plane mapping parameters were returned.
  """
  pass
 def TryGetMappingSphere(self,sphere):
  """
  TryGetMappingSphere(self: TextureMapping) -> (bool,Sphere)

  

   Get a spherical projection parameters from this texture mapping.

   Returns: Returns true if a valid sphere is returned.
  """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 Id=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The unique Id for this texture mapping object.



Get: Id(self: TextureMapping) -> Guid



"""

 MappingType=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Texture mapping type associated with this Mapping object.



Get: MappingType(self: TextureMapping) -> TextureMappingType



"""

 NormalTransform=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """For primitive based mappings,these transformations are used to map

   the world coordinate (x,y,z) point P and  surface normal N before it is

   projected to the normalized mapping primitive. The surface normal

   transformation,m_Nxyz,is always calculated from m_Pxyz.  It is a

   runtime setting that is not saved in 3dm files. If m_type is

   srfp_mapping,then m_Pxyz and m_Nxyz are ignored.



Get: NormalTransform(self: TextureMapping) -> Transform



Set: NormalTransform(self: TextureMapping)=value

"""

 PrimativeTransform=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """For primitive based mappings,these transformations are used to map

   the world coordinate (x,y,z) point P and  surface normal N before it is

   projected to the normalized mapping primitive. The surface normal

   transformation,m_Nxyz,is always calculated from m_Pxyz.  It is a

   runtime setting that is not saved in 3dm files. If m_type is

   srfp_mapping,then m_Pxyz and m_Nxyz are ignored.



Get: PrimativeTransform(self: TextureMapping) -> Transform



Set: PrimativeTransform(self: TextureMapping)=value

"""

 UvwTransform=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Transform applied to mapping coordinate (u,v,w) to convert it into a

   texture coordinate.



Get: UvwTransform(self: TextureMapping) -> Transform



Set: UvwTransform(self: TextureMapping)=value

"""



class TextureMappingType(Enum,IComparable,IFormattable,IConvertible):
 """
 Defines enumerated constants for mapping types such as planar,cylindrical or spherical.

 

 enum TextureMappingType,values: BoxMapping (5),BrepMappingPrimitive (8),CylinderMapping (3),MeshMappingPrimitive (6),None (0),PlaneMapping (2),SphereMapping (4),SurfaceMappingPrimitive (7),SurfaceParameters (1)
 """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 BoxMapping=None
 BrepMappingPrimitive=None
 CylinderMapping=None
 MeshMappingPrimitive=None
 None=None
 PlaneMapping=None
 SphereMapping=None
 SurfaceMappingPrimitive=None
 SurfaceParameters=None
 value__=None


class TextureProjectionMode(Enum,IComparable,IFormattable,IConvertible):
 """ enum TextureProjectionMode,values: EnvironmentMap (3),MappingChannel (0),Screen (5),View (1),Wcs (2),WcsBox (4) """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 EnvironmentMap=None
 MappingChannel=None
 Screen=None
 value__=None
 View=None
 Wcs=None
 WcsBox=None


class TextureWrapType(Enum,IComparable,IFormattable,IConvertible):
 """ enum TextureWrapType,values: Clamped (0),Repeating (1) """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Clamped=None
 Repeating=None
 value__=None


class TwoColorRenderTexture(RenderTexture,IDisposable):
 # no doc
 def AddAdditionalUISections(self,*args):
  """ AddAdditionalUISections(self: TwoColorRenderTexture) """
  pass
 def Dispose(self):
  """ Dispose(self: RenderContent,disposing: bool) """
  pass
 def ModifyRenderContentStyles(self,*args):
  """ ModifyRenderContentStyles(self: RenderContent,stylesToAdd: RenderContentStyles,stylesToRemove: RenderContentStyles) """
  pass
 def OnAddUserInterfaceSections(self,*args):
  """ OnAddUserInterfaceSections(self: TwoColorRenderTexture) """
  pass
 def OnGetDefaultsInteractive(self,*args):
  """
  OnGetDefaultsInteractive(self: RenderContent,parentWindowHandle: IntPtr) -> bool

  

   Override this method to prompt user for information necessary to

     create a new 

    content object.  For example,if you are created a

     textured material you may prompt 

    the user for a bitmap file name

     prior to creating the textured material.

  

   Returns: If true is returned the content is created otherwise the creation

     is aborted.
  """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 Color1=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Color1(self: TwoColorRenderTexture) -> Color4f



Set: Color1(self: TwoColorRenderTexture)=value

"""

 Color2=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Color2(self: TwoColorRenderTexture) -> Color4f



Set: Color2(self: TwoColorRenderTexture)=value

"""

 SuperSample=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: SuperSample(self: TwoColorRenderTexture) -> bool



Set: SuperSample(self: TwoColorRenderTexture)=value

"""

 SwapColors=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: SwapColors(self: TwoColorRenderTexture) -> bool



Set: SwapColors(self: TwoColorRenderTexture)=value

"""

 Texture1Amount=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Texture1Amount(self: TwoColorRenderTexture) -> float



Set: Texture1Amount(self: TwoColorRenderTexture)=value

"""

 Texture1On=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Texture1On(self: TwoColorRenderTexture) -> bool



Set: Texture1On(self: TwoColorRenderTexture)=value

"""

 Texture2Amount=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Texture2Amount(self: TwoColorRenderTexture) -> float



Set: Texture2Amount(self: TwoColorRenderTexture)=value

"""

 Texture2On=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Texture2On(self: TwoColorRenderTexture) -> bool



Set: Texture2On(self: TwoColorRenderTexture)=value

"""



class Utilities(object):
 # no doc
 @staticmethod
 def SetDefaultRenderPlugIn(pluginId):
  """
  SetDefaultRenderPlugIn(pluginId: Guid) -> bool

  

   Set default render application

  

   pluginId: ID of render plug-in

   Returns: True if plug-in found and loaded successfully.  False if pluginId is

      invalid or 

    was unable to load plug-in
  """
  pass
 __all__=[
  'SetDefaultRenderPlugIn',
 ]


# variables with complex values

