internal static Context getContext(IntPtr context)
{
if (context != IntPtr.Zero)
{
return(contexts.getObject(context));
}
return(null);
}
internal static Widget getWidget(IntPtr widget)
{
if (widget != IntPtr.Zero)
{
return(widgets.getObject(widget));
}
return(null);
}
public Source getSource(IntPtr source)
{
if (source != IntPtr.Zero)
{
return(sources.getObject(source));
}
return(null);
}
public AudioCodec getCodec(IntPtr codec, OpenALManager openALManager)
{
if (codec != IntPtr.Zero)
{
return(codecs.getObject(codec, openALManager));
}
return(null);
}
public CaptureDevice get(IntPtr ptr, OpenALManager openAlManager)
{
if (ptr != IntPtr.Zero)
{
return(wrappers.getObject(ptr, openAlManager));
}
return(null);
}
internal static Element getElement(IntPtr element)
{
if (element != IntPtr.Zero)
{
Element returnedElement = elements.getObject(element);
return(returnedElement);
}
return(null);
}
/// <summary>
/// Creates a VertexAnimationTrack for animating vertex position data.
/// </summary>
/// <param name="handle">Handle to give the track, used for accessing the track later. Must be unique within this Animation, and is used to identify the target. For example when applied to a Mesh, the handle must reference the index of the geometry being modified; 0 for the shared geometry, and 1+ for SubMesh geometry with the same index-1.</param>
/// <param name="animType">Either morph or pose animation.</param>
/// <returns>The newly created VertexAnimationTrack or null if an error occured such as the track already being defined.</returns>
public VertexAnimationTrack createVertexTrack(ushort handle, VertexAnimationType animType)
{
return(vertexAnimations.getObject(Animation_createVertexTrack(animation, handle, animType), this));
}
internal static SceneNode getManagedNode(IntPtr ogreSceneNode)
{
return(sceneNodes.getObject(ogreSceneNode));
}
/// <summary>
/// Creates a NumericAnimationTrack for animating any numeric value.
/// </summary>
/// <param name="handle">Handle to give the track, used for accessing the track later. Must be unique within this Animation.</param>
/// <returns>The newly created NumericAnimationTrack or null if an error occured such as the track already being defined.</returns>
public NumericAnimationTrack createNumericTrack(ushort handle)
{
return(numericAnimations.getObject(Animation_createNumericTrack(animation, handle), this));
}
public override KeyFrame getKeyFrame(ushort index)
{
return(keyFrames.getObject(NodeAnimationTrack_getKeyFrame(animationTrack, index)));
}
public static Viewport getViewport(IntPtr viewport)
{
return(viewports.getObject(viewport));
}
/// <summary>
/// Load a layout. It is best for memory management to be sure to call
/// unloadLayout before your program closes. Otherwise a pointer will
/// leak inside the returned Layout.
/// </summary>
/// <param name="file">The file to load.</param>
/// <returns>A Layout which is really just a collection of widgets.</returns>
public Layout loadLayout(String file)
{
return(layouts.getObject(LayoutManager_loadLayout(layoutManager, file)));
}
/// <summary>
/// Create a new AnimationState instance.
/// </summary>
/// <param name="animName">The name of the animation.</param>
/// <param name="timePos">Starting time position.</param>
/// <param name="length">Length of the animation to play.</param>
/// <param name="weight">Weight to apply the animation with.</param>
/// <param name="enabled">Whether the animation is enabled.</param>
/// <returns>A new AnimationState with the given parameters.</returns>
public AnimationState createAnimationState(String animName, float timePos, float length, float weight, bool enabled)
{
return(states.getObject(AnimationStateSet_createAnimationState(animationStateSet, animName, timePos, length, weight, enabled), this));
}
/// <summary>
/// Creates a new Animation object for animating this skeleton.
/// </summary>
/// <param name="name">The name of this animation.</param>
/// <param name="length">The length of the animation in seconds.</param>
/// <returns></returns>
public Animation createAnimation(String name, float length)
{
return(animations.getObject(Skeleton_createAnimation(skeleton, name, length)));
}
/// <summary>
/// Get a single element.
/// </summary>
/// <param name="index">The index of the element to retrieve.</param>
/// <returns>The element at the specified index.</returns>
public VertexElement getElement(ushort index)
{
return(vertexElements.getObject(VertexDeclaration_getElement(vertexDeclaration, index)));
}
/// <summary>
/// Create a ManualObject, an object which you populate with geometry manually through a
/// GL immediate-mode style interface.
/// </summary>
/// <param name="name">The name to be given to the object (must be unique). </param>
/// <returns>The newly created manual object.</returns>
public ManualObject createManualObject(String name)
{
return(manualObjects.getObject(SceneManager_createManualObject(ogreSceneManager, name)));
}
/// <summary>
/// Creates the single pose KeyFrame and adds it to this animation.
/// </summary>
/// <param name="timePos">The time from which this KeyFrame will apply. </param>
/// <returns>The new VertexPoseKeyFrame.</returns>
public VertexPoseKeyFrame createVertexPoseKeyFrame(float timePos)
{
return(poseKeyFrames.getObject(VertexAnimationTrack_createVertexPoseKeyFrame(animationTrack, timePos)));
}
/// <summary>
/// Create a Entity with the given name using the given mesh.
/// </summary>
/// <param name="entityName">The name of the entity.</param>
/// <param name="meshName">The name of the mesh to use on this entity.</param>
/// <returns>The new Entity.</returns>
public Entity createEntity(String entityName, String meshName)
{
return(entities.getObject(SceneManager_createEntity(ogreSceneManager, entityName, meshName)));
}
/// <summary>
/// Creates a new light managed by this SceneManager.
/// </summary>
/// <param name="name">The name of the light.</param>
/// <returns>A new Light wrapping a native light.</returns>
public Light createLight(String name)
{
return(lights.getObject(SceneManager_createLight(ogreSceneManager, name)));
}
public Pass createPass()
{
return(passes.getObject(Technique_createPass(technique), this));
}
/// <summary>
/// Creates a NodeAnimationTrack for animating a Node.
/// </summary>
/// <param name="handle">Handle to give the track, used for accessing the track later. Must be unique within this Animation. </param>
/// <returns>The newly created NodeAnimationTrack or null if an error occured such as the track already being defined.</returns>
public NodeAnimationTrack createNodeTrack(ushort handle)
{
return(nodeAnimations.getObject(Animation_createNodeTrack(animation, handle), this));
}
/// <summary>
/// Gets a pointer to a SubEntity, ie a part of an Entity.
/// </summary>
/// <param name="index">The index of the sub entity to find.</param>
/// <returns>The sub entity specified by index or null if it does not exist.</returns>
public SubEntity getSubEntity(uint index)
{
return(subEntities.getObject(Entity_getSubEntityIndex(ogreObject, index)));
}
public StaticGeometry createStaticGeometry(String name)
{
return(staticGeometries.getObject(SceneManager_createStaticGeometry(ogreSceneManager, name)));
}
/// <summary>
/// Creates a new Bone as a child of this bone.
///
/// This method creates a new bone which will inherit the transforms of this bone, with the
/// handle specified.
/// </summary>
/// <param name="handle">The numeric handle to give the new bone; must be unique within the Skeleton.</param>
/// <param name="translation">Initial translation offset of child relative to parent.</param>
/// <param name="rotate">Initial rotation relative to parent.</param>
/// <returns></returns>
public Bone createChild(ushort handle, Vector3 translation, Quaternion rotate)
{
return(bones.getObject(Bone_createChild(ogreNode, handle, translation, rotate)));
}
/// <summary>
/// Finish defining the object and compile the final renderable version.
/// </summary>
public ManualObjectSection end()
{
return(sections.getObject(ManualObject_end(ogreObject)));
}
/// <summary>
/// Creates a camera managed by this SceneManager.
/// </summary>
/// <param name="name">The name of the camera.</param>
/// <returns>A new Camera wrapping the native camera.</returns>
public Camera createCamera(String name)
{
return(cameras.getObject(SceneManager_createCamera(ogreSceneManager, name)));
}
/// <summary>
/// Creates a brand new Bone owned by this Skeleton.
/// </summary>
/// <returns>The new bone.</returns>
public Bone createBone()
{
return(bones.getObject(Skeleton_createBone(skeleton)));
}
public TextureUnitState createTextureUnitState()
{
return(textureUnits.getObject(Pass_createTextureUnitState(pass)));
}
public Technique createTechnique()
{
return(techniques.getObject(Material_createTechnique(resource), this));
}
/// <summary>
/// Gets a pointer to the entity representing the numbered manual level of detail.
/// The zero-based index never includes the original entity, unlike Mesh::getLodLevel.
/// </summary>
/// <param name="index">The level of detail index.</param>
/// <returns>The level of detail entity for index or null if it does not exist.</returns>
public Entity getManualLodLevel(uint index)
{
return(lodEntities.getObject(Entity_getManualLodLevel(ogreObject, index)));
}