lauchmelder/SFML
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Moved all bindings to the "bindings" sub-directory

Browse source 
Renamed the CSFML directory to c
Renamed the DSFML directory to d
--> bindings must now be updated to match the new organization!

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1630 4e206d99-4929-0410-ac5d-dfc041789085
This commit is contained in:
LaurentGom 2010-11-09 17:13:17 +00:00
parent 0cc5563cac
commit 0e2297af28
417 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

72
bindings/dotnet/src/Audio/Listener.cs Normal file
View file

@ -0,0 +1,72 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Audio
{
////////////////////////////////////////////////////////////
/// <summary>
/// Listener is a global interface for defining the audio
/// listener properties ; the audio listener is the point in
/// the scene from where all the sounds are heard
/// </summary>
////////////////////////////////////////////////////////////
public class Listener
{
////////////////////////////////////////////////////////////
/// <summary>
/// Global volume of all sounds, in range [0 .. 100] (default is 100)
/// </summary>
////////////////////////////////////////////////////////////
public static float GlobalVolume
{
get {return sfListener_GetGlobalVolume();}
set {sfListener_SetGlobalVolume(value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// 3D position of the listener (default is (0, 0, 0))
/// </summary>
////////////////////////////////////////////////////////////
public static Vector3 Position
{
get {Vector3 v; sfListener_GetPosition(out v.X, out v.Y, out v.Z); return v;}
set {sfListener_SetPosition(value.X, value.Y, value.Z);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// 3D direction of the listener (default is (0, 0, -1))
/// </summary>
////////////////////////////////////////////////////////////
public static Vector3 Direction
{
get {Vector3 v; sfListener_GetDirection(out v.X, out v.Y, out v.Z); return v;}
set {sfListener_SetDirection(value.X, value.Y, value.Z);}
}
#region Imports
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfListener_SetGlobalVolume(float Volume);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfListener_GetGlobalVolume();
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfListener_SetPosition(float X, float Y, float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfListener_GetPosition(out float X, out float Y, out float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfListener_SetDirection(float X, float Y, float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfListener_GetDirection(out float X, out float Y, out float Z);
#endregion
}
}
}

333
bindings/dotnet/src/Audio/Music.cs Normal file
View file

@ -0,0 +1,333 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.IO;
namespace SFML
{
namespace Audio
{
////////////////////////////////////////////////////////////
/// <summary>
/// Music defines a big sound played using streaming,
/// so usually what we call a music :)
/// </summary>
////////////////////////////////////////////////////////////
public class Music : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the music from a file
/// </summary>
/// <param name="filename">Path of the music file to load</param>
////////////////////////////////////////////////////////////
public Music(string filename) :
base(sfMusic_CreateFromFile(filename))
{
if (This == IntPtr.Zero)
throw new LoadingFailedException("music", filename);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the music from a file in a stream
/// </summary>
/// <param name="stream">Stream containing the file contents</param>
////////////////////////////////////////////////////////////
public Music(Stream stream) :
base(IntPtr.Zero)
{
stream.Position = 0;
byte[] StreamData = new byte[stream.Length];
uint Read = (uint)stream.Read(StreamData, 0, StreamData.Length);
unsafe
{
fixed (byte* dataPtr = StreamData)
{
SetThis(sfMusic_CreateFromMemory((char*)dataPtr, Read));
}
}
if (This == IntPtr.Zero)
throw new LoadingFailedException("music");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Play the music
/// </summary>
////////////////////////////////////////////////////////////
public void Play()
{
sfMusic_Play(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Pause the music
/// </summary>
////////////////////////////////////////////////////////////
public void Pause()
{
sfMusic_Pause(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Stop the music
/// </summary>
////////////////////////////////////////////////////////////
public void Stop()
{
sfMusic_Stop(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Samples rate, in samples per second
/// </summary>
////////////////////////////////////////////////////////////
public uint SampleRate
{
get {return sfMusic_GetSampleRate(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Number of channels (1 = mono, 2 = stereo)
/// </summary>
////////////////////////////////////////////////////////////
public uint ChannelsCount
{
get {return sfMusic_GetChannelsCount(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Current status of the music (see SoundStatus enum)
/// </summary>
////////////////////////////////////////////////////////////
public SoundStatus Status
{
get {return sfMusic_GetStatus(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Total duration of the music, in seconds
/// </summary>
////////////////////////////////////////////////////////////
public float Duration
{
get {return sfMusic_GetDuration(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Loop state of the sound. Default value is false
/// </summary>
////////////////////////////////////////////////////////////
public bool Loop
{
get {return sfMusic_GetLoop(This);}
set {sfMusic_SetLoop(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Pitch of the music. Default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float Pitch
{
get {return sfMusic_GetPitch(This);}
set {sfMusic_SetPitch(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Volume of the music, in range [0, 100]. Default value is 100
/// </summary>
////////////////////////////////////////////////////////////
public float Volume
{
get {return sfMusic_GetVolume(This);}
set {sfMusic_SetVolume(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// 3D position of the music. Default value is (0, 0, 0)
/// </summary>
////////////////////////////////////////////////////////////
public Vector3 Position
{
get {Vector3 v; sfMusic_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
set {sfMusic_SetPosition(This, value.X, value.Y, value.Z);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Is the music's position relative to the listener's position,
/// or is it absolute?
/// Default value is false (absolute)
/// </summary>
////////////////////////////////////////////////////////////
public bool RelativeToListener
{
get {return sfMusic_IsRelativeToListener(This);}
set {sfMusic_SetRelativeToListener(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Minimum distance of the music. Closer than this distance,
/// the listener will hear the sound at its maximum volume.
/// The default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float MinDistance
{
get {return sfMusic_GetMinDistance(This);}
set {sfMusic_SetMinDistance(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Attenuation factor. The higher the attenuation, the
/// more the sound will be attenuated with distance from listener.
/// The default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float Attenuation
{
get {return sfMusic_GetAttenuation(This);}
set {sfMusic_SetAttenuation(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Current playing position, in seconds
/// </summary>
////////////////////////////////////////////////////////////
public float PlayingOffset
{
get {return sfMusic_GetPlayingOffset(This);}
set {sfMusic_SetPlayingOffset(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Music]" +
" SampleRate(" + SampleRate + ")" +
" ChannelsCount(" + ChannelsCount + ")" +
" Status(" + Status + ")" +
" Duration(" + Duration + ")" +
" Loop(" + Loop + ")" +
" Pitch(" + Pitch + ")" +
" Volume(" + Volume + ")" +
" Position(" + Position + ")" +
" RelativeToListener(" + RelativeToListener + ")" +
" MinDistance(" + MinDistance + ")" +
" Attenuation(" + Attenuation + ")" +
" PlayingOffset(" + PlayingOffset + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfMusic_Destroy(This);
}
#region Imports
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfMusic_CreateFromFile(string Filename);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern IntPtr sfMusic_CreateFromMemory(char* Data, uint SizeInBytes);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_Destroy(IntPtr MusicStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_Play(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_Pause(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_Stop(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern SoundStatus sfMusic_GetStatus(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfMusic_GetDuration(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfMusic_GetChannelsCount(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfMusic_GetSampleRate(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_SetPitch(IntPtr Music, float Pitch);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_SetLoop(IntPtr Music, bool Loop);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_SetVolume(IntPtr Music, float Volume);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_SetPosition(IntPtr Music, float X, float Y, float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_SetRelativeToListener(IntPtr Music, bool Relative);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_SetMinDistance(IntPtr Music, float MinDistance);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_SetAttenuation(IntPtr Music, float Attenuation);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_SetPlayingOffset(IntPtr Music, float TimeOffset);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfMusic_GetLoop(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfMusic_GetPitch(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfMusic_GetVolume(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMusic_GetPosition(IntPtr Music, out float X, out float Y, out float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfMusic_IsRelativeToListener(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfMusic_GetMinDistance(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfMusic_GetAttenuation(IntPtr Music);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfMusic_GetPlayingOffset(IntPtr Music);
#endregion
}
}
}

325
bindings/dotnet/src/Audio/Sound.cs Normal file
View file

@ -0,0 +1,325 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Audio
{
////////////////////////////////////////////////////////////
/// <summary>
/// Enumeration of all possible sound states
/// </summary>
////////////////////////////////////////////////////////////
public enum SoundStatus
{
/// <summary>Sound is not playing</summary>
Stopped,
/// <summary>Sound is paused</summary>
Paused,
/// <summary>Sound is playing</summary>
Playing
}
////////////////////////////////////////////////////////////
/// <summary>
/// Sound defines the properties of a sound such as position,
/// volume, pitch, etc.
/// </summary>
////////////////////////////////////////////////////////////
public class Sound : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor (invalid sound)
/// </summary>
////////////////////////////////////////////////////////////
public Sound() :
base(sfSound_Create())
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the sound from a source buffer
/// </summary>
/// <param name="buffer">Sound buffer to play</param>
////////////////////////////////////////////////////////////
public Sound(SoundBuffer buffer) :
base(sfSound_Create())
{
SoundBuffer = buffer;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the sound from another source
/// </summary>
/// <param name="copy">Sound to copy</param>
////////////////////////////////////////////////////////////
public Sound(Sound copy) :
base(sfSound_Copy(copy.This))
{
SoundBuffer = copy.SoundBuffer;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Play the sound
/// </summary>
////////////////////////////////////////////////////////////
public void Play()
{
sfSound_Play(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Pause the sound
/// </summary>
////////////////////////////////////////////////////////////
public void Pause()
{
sfSound_Pause(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Stop the sound
/// </summary>
////////////////////////////////////////////////////////////
public void Stop()
{
sfSound_Stop(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Buffer containing the sound data to play through the sound
/// </summary>
////////////////////////////////////////////////////////////
public SoundBuffer SoundBuffer
{
get {return myBuffer;}
set {myBuffer = value; sfSound_SetBuffer(This, value != null ? value.This : IntPtr.Zero);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Current status of the sound (see SoundStatus enum)
/// </summary>
////////////////////////////////////////////////////////////
public SoundStatus Status
{
get {return sfSound_GetStatus(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Loop state of the sound. Default value is false
/// </summary>
////////////////////////////////////////////////////////////
public bool Loop
{
get {return sfSound_GetLoop(This);}
set {sfSound_SetLoop(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Pitch of the sound. Default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float Pitch
{
get {return sfSound_GetPitch(This);}
set {sfSound_SetPitch(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Volume of the sound, in range [0, 100]. Default value is 100
/// </summary>
////////////////////////////////////////////////////////////
public float Volume
{
get {return sfSound_GetVolume(This);}
set {sfSound_SetVolume(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Current playing position of the sound, in seconds
/// </summary>
////////////////////////////////////////////////////////////
public float PlayingOffset
{
get {return sfSound_GetPlayingOffset(This);}
set {sfSound_SetPlayingOffset(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// 3D position of the sound. Default value is (0, 0, 0)
/// </summary>
////////////////////////////////////////////////////////////
public Vector3 Position
{
get {Vector3 v; sfSound_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
set {sfSound_SetPosition(This, value.X, value.Y, value.Z);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Is the sound's position relative to the listener's position,
/// or is it absolute?
/// Default value is false (absolute)
/// </summary>
////////////////////////////////////////////////////////////
public bool RelativeToListener
{
get {return sfSound_IsRelativeToListener(This);}
set {sfSound_SetRelativeToListener(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Minimum distance of the sound. Closer than this distance,
/// the listener will hear the sound at its maximum volume.
/// The default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float MinDistance
{
get {return sfSound_GetMinDistance(This);}
set {sfSound_SetMinDistance(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Attenuation factor. The higher the attenuation, the
/// more the sound will be attenuated with distance from listener.
/// The default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float Attenuation
{
get {return sfSound_GetAttenuation(This);}
set {sfSound_SetAttenuation(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Sound]" +
" Status(" + Status + ")" +
" Loop(" + Loop + ")" +
" Pitch(" + Pitch + ")" +
" Volume(" + Volume + ")" +
" Position(" + Position + ")" +
" RelativeToListener(" + RelativeToListener + ")" +
" MinDistance(" + MinDistance + ")" +
" Attenuation(" + Attenuation + ")" +
" PlayingOffset(" + PlayingOffset + ")" +
" SoundBuffer(" + SoundBuffer + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfSound_Destroy(This);
}
private SoundBuffer myBuffer;
#region Imports
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSound_Create();
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSound_Copy(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_Destroy(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_Play(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_Pause(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_Stop(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetBuffer(IntPtr Sound, IntPtr Buffer);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSound_GetBuffer(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetLoop(IntPtr Sound, bool Loop);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfSound_GetLoop(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern SoundStatus sfSound_GetStatus(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetPitch(IntPtr Sound, float Pitch);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetVolume(IntPtr Sound, float Volume);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetPosition(IntPtr Sound, float X, float Y, float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetRelativeToListener(IntPtr Sound, bool Relative);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetMinDistance(IntPtr Sound, float MinDistance);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetAttenuation(IntPtr Sound, float Attenuation);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_SetPlayingOffset(IntPtr Sound, float TimeOffset);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSound_GetPitch(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSound_GetVolume(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSound_GetPosition(IntPtr Sound, out float X, out float Y, out float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfSound_IsRelativeToListener(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSound_GetMinDistance(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSound_GetAttenuation(IntPtr Sound);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSound_GetPlayingOffset(IntPtr Sound);
#endregion
}
}
}

209
bindings/dotnet/src/Audio/SoundBuffer.cs Normal file
View file

@ -0,0 +1,209 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.IO;
namespace SFML
{
namespace Audio
{
////////////////////////////////////////////////////////////
/// <summary>
/// SoundBuffer is the low-level class for loading and manipulating
/// sound buffers. A sound buffer holds audio data (samples)
/// which can then be played by a Sound or saved to a file.
/// </summary>
////////////////////////////////////////////////////////////
public class SoundBuffer : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the sound buffer from a file
/// </summary>
/// <param name="filename">Path of the sound file to load</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public SoundBuffer(string filename) :
base(sfSoundBuffer_CreateFromFile(filename))
{
if (This == IntPtr.Zero)
throw new LoadingFailedException("sound buffer", filename);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the sound buffer from a file in a stream
/// </summary>
/// <param name="stream">Stream containing the file contents</param>
////////////////////////////////////////////////////////////
public SoundBuffer(Stream stream) :
base(IntPtr.Zero)
{
stream.Position = 0;
byte[] StreamData = new byte[stream.Length];
uint Read = (uint)stream.Read(StreamData, 0, StreamData.Length);
unsafe
{
fixed (byte* dataPtr = StreamData)
{
SetThis(sfSoundBuffer_CreateFromMemory((char*)dataPtr, Read));
}
}
if (This == IntPtr.Zero)
throw new LoadingFailedException("sound buffer");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the sound buffer from an array of samples
/// </summary>
/// <param name="samples">Array of samples</param>
/// <param name="channelsCount">Channels count</param>
/// <param name="sampleRate">Sample rate</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public SoundBuffer(short[] samples, uint channelsCount, uint sampleRate) :
base(IntPtr.Zero)
{
unsafe
{
fixed (short* SamplesPtr = samples)
{
SetThis(sfSoundBuffer_CreateFromSamples(SamplesPtr, (uint)samples.Length, channelsCount, sampleRate));
}
}
if (This == IntPtr.Zero)
throw new LoadingFailedException("sound buffer");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the sound buffer from another sound buffer
/// </summary>
/// <param name="copy">Sound buffer to copy</param>
////////////////////////////////////////////////////////////
public SoundBuffer(SoundBuffer copy) :
base(sfSoundBuffer_Copy(copy.This))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Save the sound buffer to an audio file
/// </summary>
/// <param name="filename">Path of the sound file to write</param>
/// <returns>True if saving has been successful</returns>
////////////////////////////////////////////////////////////
public bool SaveToFile(string filename)
{
return sfSoundBuffer_SaveToFile(This, filename);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Samples rate, in samples per second
/// </summary>
////////////////////////////////////////////////////////////
public uint SampleRate
{
get {return sfSoundBuffer_GetSampleRate(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Number of channels (1 = mono, 2 = stereo)
/// </summary>
////////////////////////////////////////////////////////////
public uint ChannelsCount
{
get {return sfSoundBuffer_GetChannelsCount(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Total duration of the buffer, in seconds
/// </summary>
////////////////////////////////////////////////////////////
public float Duration
{
get {return sfSoundBuffer_GetDuration(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Array of samples contained in the buffer
/// </summary>
////////////////////////////////////////////////////////////
public short[] Samples
{
get
{
short[] SamplesArray = new short[sfSoundBuffer_GetSamplesCount(This)];
Marshal.Copy(sfSoundBuffer_GetSamples(This), SamplesArray, 0, SamplesArray.Length);
return SamplesArray;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[SoundBuffer]" +
" SampleRate(" + SampleRate + ")" +
" ChannelsCount(" + ChannelsCount + ")" +
" Duration(" + Duration + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfSoundBuffer_Destroy(This);
}
#region Imports
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSoundBuffer_CreateFromFile(string Filename);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern IntPtr sfSoundBuffer_CreateFromMemory(char* Data, uint SizeInBytes);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern IntPtr sfSoundBuffer_CreateFromSamples(short* Samples, uint SamplesCount, uint ChannelsCount, uint SampleRate);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSoundBuffer_Copy(IntPtr SoundBuffer);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundBuffer_Destroy(IntPtr SoundBuffer);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfSoundBuffer_SaveToFile(IntPtr SoundBuffer, string Filename);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSoundBuffer_GetSamples(IntPtr SoundBuffer);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfSoundBuffer_GetSamplesCount(IntPtr SoundBuffer);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfSoundBuffer_GetSampleRate(IntPtr SoundBuffer);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfSoundBuffer_GetChannelsCount(IntPtr SoundBuffer);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSoundBuffer_GetDuration(IntPtr SoundBuffer);
#endregion
}
}
}

83
bindings/dotnet/src/Audio/SoundBufferRecorder.cs Normal file
View file

@ -0,0 +1,83 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Collections.Generic;
namespace SFML
{
namespace Audio
{
////////////////////////////////////////////////////////////
/// <summary>
/// Specialized SoundRecorder which saves the captured
/// audio data into a sound buffer
/// </summary>
////////////////////////////////////////////////////////////
public class SoundBufferRecorder : SoundRecorder
{
////////////////////////////////////////////////////////////
/// <summary>
/// Sound buffer containing the recorded data (invalid until the capture stops)
/// </summary>
////////////////////////////////////////////////////////////
public SoundBuffer SoundBuffer
{
get
{
return mySoundBuffer;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[SoundBufferRecorder]" +
" SampleRate(" + SampleRate + ")" +
" SoundBuffer(" + SoundBuffer + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Called when a new capture starts
/// </summary>
/// <returns>False to abort recording audio data, true to continue</returns>
////////////////////////////////////////////////////////////
protected override bool OnStart()
{
mySamplesArray.Clear();
return true;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Process a new chunk of recorded samples
/// </summary>
/// <param name="samples">Array of samples to process</param>
/// <returns>False to stop recording audio data, true to continue</returns>
////////////////////////////////////////////////////////////
protected override bool OnProcessSamples(short[] samples)
{
mySamplesArray.AddRange(samples);
return true;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Called when the current capture stops
/// </summary>
////////////////////////////////////////////////////////////
protected override void OnStop()
{
mySoundBuffer = new SoundBuffer(mySamplesArray.ToArray(), 1, SampleRate);
}
List<short> mySamplesArray = new List<short>();
SoundBuffer mySoundBuffer = null;
}
}
}

192
bindings/dotnet/src/Audio/SoundRecorder.cs Normal file
View file

@ -0,0 +1,192 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Audio
{
////////////////////////////////////////////////////////////
/// <summary>
/// SoundRecorder is an interface for capturing sound data,
/// it is meant to be used as a base class
/// </summary>
////////////////////////////////////////////////////////////
public abstract class SoundRecorder : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor
/// </summary>
////////////////////////////////////////////////////////////
public SoundRecorder() :
base(IntPtr.Zero)
{
myStartCallback = new StartCallback(OnStart);
myProcessCallback = new ProcessCallback(ProcessSamples);
myStopCallback = new StopCallback(OnStop);
SetThis(sfSoundRecorder_Create(myStartCallback, myProcessCallback, myStopCallback, IntPtr.Zero));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Start the capture using default sample rate (44100 Hz)
/// Warning : only one capture can happen at the same time
/// </summary>
////////////////////////////////////////////////////////////
public void Start()
{
Start(44100);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Start the capture.
/// Warning : only one capture can happen at the same time
/// </summary>
/// <param name="sampleRate"> Sound frequency; the more samples, the higher the quality (44100 by default = CD quality)</param>
////////////////////////////////////////////////////////////
public void Start(uint sampleRate)
{
sfSoundRecorder_Start(This, sampleRate);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Stop the capture
/// </summary>
////////////////////////////////////////////////////////////
public void Stop()
{
sfSoundRecorder_Stop(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Sample rate of the recorder, in samples per second
/// </summary>
////////////////////////////////////////////////////////////
public uint SampleRate
{
get {return sfSoundRecorder_GetSampleRate(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Tell if the system supports sound capture.
/// If not, this class won't be usable
/// </summary>
////////////////////////////////////////////////////////////
public static bool IsAvailable
{
get {return sfSoundRecorder_IsAvailable();}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[SoundRecorder]" +
" SampleRate(" + SampleRate + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Called when a new capture starts
/// </summary>
/// <returns>False to abort recording audio data, true to continue</returns>
////////////////////////////////////////////////////////////
protected virtual bool OnStart()
{
// Does nothing by default
return true;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Process a new chunk of recorded samples
/// </summary>
/// <param name="samples">Array of samples to process</param>
/// <returns>False to stop recording audio data, true to continue</returns>
////////////////////////////////////////////////////////////
protected abstract bool OnProcessSamples(short[] samples);
////////////////////////////////////////////////////////////
/// <summary>
/// Called when the current capture stops
/// </summary>
////////////////////////////////////////////////////////////
protected virtual void OnStop()
{
// Does nothing by default
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfSoundRecorder_Destroy(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Function called directly by the C library ; convert
/// arguments and forward them to the internal virtual function
/// </summary>
/// <param name="samples">Pointer to the array of samples</param>
/// <param name="nbSamples">Number of samples in the array</param>
/// <param name="userData">User data -- unused</param>
/// <returns>False to stop recording audio data, true to continue</returns>
////////////////////////////////////////////////////////////
private bool ProcessSamples(IntPtr samples, uint nbSamples, IntPtr userData)
{
short[] samplesArray = new short[nbSamples];
Marshal.Copy(samples, samplesArray, 0, samplesArray.Length);
return OnProcessSamples(samplesArray);
}
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate bool StartCallback();
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate bool ProcessCallback(IntPtr samples, uint nbSamples, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void StopCallback();
private StartCallback myStartCallback;
private ProcessCallback myProcessCallback;
private StopCallback myStopCallback;
#region Imports
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSoundRecorder_Create(StartCallback OnStart, ProcessCallback OnProcess, StopCallback OnStop, IntPtr UserData);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundRecorder_Destroy(IntPtr SoundRecorder);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundRecorder_Start(IntPtr SoundRecorder, uint SampleRate);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundRecorder_Stop(IntPtr SoundRecorder);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfSoundRecorder_GetSampleRate(IntPtr SoundRecorder);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfSoundRecorder_IsAvailable();
#endregion
}
}
}

386
bindings/dotnet/src/Audio/SoundStream.cs Normal file
View file

@ -0,0 +1,386 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Audio
{
////////////////////////////////////////////////////////////
/// <summary>
/// SoundStream is a streamed sound, ie. samples are acquired
/// while the sound is playing. Use it for big sounds that would
/// require hundreds of MB in memory (see Music),
/// or for streaming sound from the network
/// </summary>
////////////////////////////////////////////////////////////
public abstract class SoundStream : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor
/// </summary>
////////////////////////////////////////////////////////////
public SoundStream() :
base(IntPtr.Zero)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Play the sound stream
/// </summary>
////////////////////////////////////////////////////////////
public void Play()
{
sfSoundStream_Play(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Pause the sound stream
/// </summary>
////////////////////////////////////////////////////////////
public void Pause()
{
sfSoundStream_Pause(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Stop the sound stream
/// </summary>
////////////////////////////////////////////////////////////
public void Stop()
{
sfSoundStream_Stop(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Samples rate, in samples per second
/// </summary>
////////////////////////////////////////////////////////////
public uint SampleRate
{
get {return sfSoundStream_GetSampleRate(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Number of channels (1 = mono, 2 = stereo)
/// </summary>
////////////////////////////////////////////////////////////
public uint ChannelsCount
{
get {return sfSoundStream_GetChannelsCount(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Current status of the sound stream (see SoundStatus enum)
/// </summary>
////////////////////////////////////////////////////////////
public SoundStatus Status
{
get {return sfSoundStream_GetStatus(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Loop state of the sound stream. Default value is false
/// </summary>
////////////////////////////////////////////////////////////
public bool Loop
{
get {return sfSoundStream_GetLoop(This);}
set {sfSoundStream_SetLoop(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Pitch of the sound stream. Default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float Pitch
{
get {return sfSoundStream_GetPitch(This);}
set {sfSoundStream_SetPitch(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Volume of the sound stream, in range [0, 100]. Default value is 100
/// </summary>
////////////////////////////////////////////////////////////
public float Volume
{
get {return sfSoundStream_GetVolume(This);}
set {sfSoundStream_SetVolume(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// 3D position of the sound stream. Default value is (0, 0, 0)
/// </summary>
////////////////////////////////////////////////////////////
public Vector3 Position
{
get {Vector3 v; sfSoundStream_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
set {sfSoundStream_SetPosition(This, value.X, value.Y, value.Z);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Is the sound stream's position relative to the listener's position,
/// or is it absolute?
/// Default value is false (absolute)
/// </summary>
////////////////////////////////////////////////////////////
public bool RelativeToListener
{
get {return sfSoundStream_IsRelativeToListener(This);}
set {sfSoundStream_SetRelativeToListener(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Minimum distance of the sound stream. Closer than this distance,
/// the listener will hear the sound at its maximum volume.
/// The default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float MinDistance
{
get {return sfSoundStream_GetMinDistance(This);}
set {sfSoundStream_SetMinDistance(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Attenuation factor. The higher the attenuation, the
/// more the sound will be attenuated with distance from listener.
/// The default value is 1
/// </summary>
////////////////////////////////////////////////////////////
public float Attenuation
{
get {return sfSoundStream_GetAttenuation(This);}
set {sfSoundStream_SetAttenuation(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Current playing position, in seconds
/// </summary>
////////////////////////////////////////////////////////////
public float PlayingOffset
{
get {return sfSoundStream_GetPlayingOffset(This);}
set {sfSoundStream_SetPlayingOffset(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[SoundStream]" +
" SampleRate(" + SampleRate + ")" +
" ChannelsCount(" + ChannelsCount + ")" +
" Status(" + Status + ")" +
" Loop(" + Loop + ")" +
" Pitch(" + Pitch + ")" +
" Volume(" + Volume + ")" +
" Position(" + Position + ")" +
" RelativeToListener(" + RelativeToListener + ")" +
" MinDistance(" + MinDistance + ")" +
" Attenuation(" + Attenuation + ")" +
" PlayingOffset(" + PlayingOffset + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Set the audio stream parameters, you must call it before Play()
/// </summary>
/// <param name="sampleRate">Number of channels</param>
/// <param name="channelsCount">Sample rate, in samples per second</param>
////////////////////////////////////////////////////////////
protected void Initialize(uint channelsCount, uint sampleRate)
{
myGetDataCallback = new GetDataCallbackType(GetData);
mySeekCallback = new SeekCallbackType(Seek);
SetThis(sfSoundStream_Create(myGetDataCallback, mySeekCallback, channelsCount, sampleRate, IntPtr.Zero));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Virtual function called each time new audio data is needed to feed the stream
/// </summary>
/// <param name="samples">Array of samples to fill for the stream</param>
/// <returns>True to continue playback, false to stop</returns>
////////////////////////////////////////////////////////////
protected abstract bool OnGetData(out short[] samples);
////////////////////////////////////////////////////////////
/// <summary>
/// Virtual function called to seek into the stream
/// </summary>
/// <param name="timeOffset">New position, expressed in seconds</param>
////////////////////////////////////////////////////////////
protected abstract void OnSeek(float timeOffset);
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfSoundStream_Destroy(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Structure mapping the C library arguments passed to the data callback
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
private struct Chunk
{
unsafe public short* samplesPtr;
public uint samplesCount;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Called each time new audio data is needed to feed the stream
/// </summary>
/// <param name="dataChunk">Data chunk to fill with new audio samples</param>
/// <param name="userData">User data -- unused</param>
/// <returns>True to continue playback, false to stop</returns>
////////////////////////////////////////////////////////////
private bool GetData(ref Chunk dataChunk, IntPtr userData)
{
if (OnGetData(out myTempBuffer))
{
unsafe
{
fixed (short* samplesPtr = myTempBuffer)
{
dataChunk.samplesPtr = samplesPtr;
dataChunk.samplesCount = (uint)myTempBuffer.Length;
}
}
return true;
}
else
{
return false;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Called to seek in the stream
/// </summary>
/// <param name="timeOffset">New position, expressed in seconds</param>
/// <param name="userData">User data -- unused</param>
/// <returns>If false is returned, the playback is aborted</returns>
////////////////////////////////////////////////////////////
private void Seek(float timeOffset, IntPtr userData)
{
OnSeek(timeOffset);
}
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate bool GetDataCallbackType(ref Chunk dataChunk, IntPtr UserData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void SeekCallbackType(float timeOffset, IntPtr UserData);
private GetDataCallbackType myGetDataCallback;
private SeekCallbackType mySeekCallback;
private short[] myTempBuffer;
#region Imports
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSoundStream_Create(GetDataCallbackType OnGetData, SeekCallbackType OnSeek, uint ChannelsCount, uint SampleRate, IntPtr UserData);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_Destroy(IntPtr SoundStreamStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_Play(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_Pause(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_Stop(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern SoundStatus sfSoundStream_GetStatus(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfSoundStream_GetChannelsCount(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfSoundStream_GetSampleRate(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_SetLoop(IntPtr SoundStream, bool Loop);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_SetPitch(IntPtr SoundStream, float Pitch);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_SetVolume(IntPtr SoundStream, float Volume);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_SetPosition(IntPtr SoundStream, float X, float Y, float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_SetRelativeToListener(IntPtr SoundStream, bool Relative);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_SetMinDistance(IntPtr SoundStream, float MinDistance);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_SetAttenuation(IntPtr SoundStream, float Attenuation);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_SetPlayingOffset(IntPtr SoundStream, float TimeOffset);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfSoundStream_GetLoop(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSoundStream_GetPitch(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSoundStream_GetVolume(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSoundStream_GetPosition(IntPtr SoundStream, out float X, out float Y, out float Z);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfSoundStream_IsRelativeToListener(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSoundStream_GetMinDistance(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSoundStream_GetAttenuation(IntPtr SoundStream);
[DllImport("csfml-audio-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSoundStream_GetPlayingOffset(IntPtr SoundStream);
#endregion
}
}
}

133
bindings/dotnet/src/Audio/Vector3.cs Normal file
View file

@ -0,0 +1,133 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Audio
{
////////////////////////////////////////////////////////////
/// <summary>
/// Vector3 is an utility class for manipulating 3 dimensional
/// vectors with float components
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct Vector3
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the vector from its coordinates
/// </summary>
/// <param name="x">X coordinate</param>
/// <param name="y">Y coordinate</param>
/// <param name="z">Z coordinate</param>
////////////////////////////////////////////////////////////
public Vector3(float x, float y, float z)
{
X = x;
Y = y;
Z = z;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; returns the opposite of a vector
/// </summary>
/// <param name="v">Vector to negate</param>
/// <returns>-v</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator -(Vector3 v)
{
return new Vector3(-v.X, -v.Y, -v.Z);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; subtracts two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 - v2</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator -(Vector3 v1, Vector3 v2)
{
return new Vector3(v1.X - v2.X, v1.Y - v2.X, v1.Z - v2.Z);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator + overload ; add two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 + v2</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator +(Vector3 v1, Vector3 v2)
{
return new Vector3(v1.X + v2.X, v1.Y + v2.X, v1.Z + v2.Z);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v * x</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator *(Vector3 v, float x)
{
return new Vector3(v.X * x, v.Y * x, v.Z * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a scalar value by a vector
/// </summary>
/// <param name="x">Scalar value</param>
/// <param name="v">Vector</param>
/// <returns>x * v</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator *(float x, Vector3 v)
{
return new Vector3(v.X * x, v.Y * x, v.Z * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator / overload ; divide a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v / x</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator /(Vector3 v, float x)
{
return new Vector3(v.X / x, v.Y / x, v.Z / x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Vector3]" +
" X(" + X + ")" +
" Y(" + Y + ")" +
" Z(" + Z + ")";
}
/// <summary>X (horizontal) component of the vector</summary>
public float X;
/// <summary>Y (vertical) component of the vector</summary>
public float Y;
/// <summary>Z (depth) component of the vector</summary>
public float Z;
}
}
}

69
bindings/dotnet/src/Audio/sfml-audio.csproj Normal file
View file

@ -0,0 +1,69 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{0B202C4D-A457-47FE-84A3-031DD878C6BE}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>SFML.Audio</RootNamespace>
<AssemblyName>sfmlnet-audio-2</AssemblyName>
<StartupObject>
</StartupObject>
<FileUpgradeFlags>
</FileUpgradeFlags>
<OldToolsVersion>2.0</OldToolsVersion>
<UpgradeBackupLocation>
</UpgradeBackupLocation>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>..\..\lib\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<DocumentationFile>..\..\doc\build\audio-doc.xml</DocumentationFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>..\..\lib\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<DocumentationFile>..\..\doc\build\audio-doc.xml</DocumentationFile>
</PropertyGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<ItemGroup>
<Compile Include="Listener.cs" />
<Compile Include="Music.cs" />
<Compile Include="Sound.cs" />
<Compile Include="SoundBuffer.cs" />
<Compile Include="SoundBufferRecorder.cs" />
<Compile Include="SoundRecorder.cs" />
<Compile Include="SoundStream.cs" />
<Compile Include="Vector3.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Window\sfml-window.csproj">
<Project>{D17DE83D-A592-461F-8AF2-53F9E22E1D0F}</Project>
<Name>sfml-window</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>

110
bindings/dotnet/src/Graphics/Color.cs Normal file
View file

@ -0,0 +1,110 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Utility class for manipulating 32-bits RGBA colors
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct Color
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the color from its red, green and blue components
/// </summary>
/// <param name="red">Red component</param>
/// <param name="green">Green component</param>
/// <param name="blue">Blue component</param>
////////////////////////////////////////////////////////////
public Color(byte red, byte green, byte blue) :
this(red, green, blue, 255)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the color from its red, green, blue and alpha components
/// </summary>
/// <param name="red">Red component</param>
/// <param name="green">Green component</param>
/// <param name="blue">Blue component</param>
/// <param name="alpha">Alpha (transparency) component</param>
////////////////////////////////////////////////////////////
public Color(byte red, byte green, byte blue, byte alpha)
{
R = red;
G = green;
B = blue;
A = alpha;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the color from another
/// </summary>
/// <param name="color">Color to copy</param>
////////////////////////////////////////////////////////////
public Color(Color color) :
this(color.R, color.G, color.B, color.A)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Color]" +
" R(" + R + ")" +
" G(" + G + ")" +
" B(" + B + ")" +
" A(" + A + ")";
}
/// <summary>Red component of the color</summary>
public byte R;
/// <summary>Green component of the color</summary>
public byte G;
/// <summary>Blue component of the color</summary>
public byte B;
/// <summary>Alpha (transparent) component of the color</summary>
public byte A;
/// <summary>Predefined black color</summary>
public static readonly Color Black = new Color(0, 0, 0);
/// <summary>Predefined white color</summary>
public static readonly Color White = new Color(255, 255, 255);
/// <summary>Predefined red color</summary>
public static readonly Color Red = new Color(255, 0, 0);
/// <summary>Predefined green color</summary>
public static readonly Color Green = new Color(0, 255, 0);
/// <summary>Predefined blue color</summary>
public static readonly Color Blue = new Color(0, 0, 255);
/// <summary>Predefined yellow color</summary>
public static readonly Color Yellow = new Color(255, 255, 0);
/// <summary>Predefined magenta color</summary>
public static readonly Color Magenta = new Color(255, 0, 255);
/// <summary>Predefined cyan color</summary>
public static readonly Color Cyan = new Color(0, 255, 255);
}
}
}

91
bindings/dotnet/src/Graphics/Context.cs Normal file
View file

@ -0,0 +1,91 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Runtime.ConstrainedExecution;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// This class defines
/// </summary>
////////////////////////////////////////////////////////////
internal class Context : CriticalFinalizerObject
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor
/// </summary>
////////////////////////////////////////////////////////////
public Context()
{
myThis = sfContext_Create();
}
////////////////////////////////////////////////////////////
/// <summary>
/// Finalizer
/// </summary>
////////////////////////////////////////////////////////////
~Context()
{
sfContext_Destroy(myThis);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Activate or deactivate the context
/// </summary>
/// <param name="active">True to activate, false to deactivate</param>
////////////////////////////////////////////////////////////
public void SetActive(bool active)
{
sfContext_SetActive(myThis, active);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Global helper context
/// </summary>
////////////////////////////////////////////////////////////
public static Context Global
{
get
{
if (ourGlobalContext == null)
ourGlobalContext = new Context();
return ourGlobalContext;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Context]";
}
private static Context ourGlobalContext = null;
private IntPtr myThis = IntPtr.Zero;
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfContext_Create();
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfContext_Destroy(IntPtr View);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfContext_SetActive(IntPtr View, bool Active);
#endregion
}
}
}

129
bindings/dotnet/src/Graphics/Drawable.cs Normal file
View file

@ -0,0 +1,129 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Enumerate the blending modes available for drawable objects
/// </summary>
////////////////////////////////////////////////////////////
public enum BlendMode
{
/// <summary>Pixel = Src * a + Dest * (1 - a)</summary>
Alpha,
/// <summary>Pixel = Src + Dest</summary>
Add,
/// <summary>Pixel = Src * Dest</summary>
Multiply,
/// <summary>No blending</summary>
None
}
////////////////////////////////////////////////////////////
/// <summary>
/// Abstract base class for every object that can be drawn
/// into a render window
/// </summary>
////////////////////////////////////////////////////////////
public abstract class Drawable : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Position of the object on screen
/// </summary>
////////////////////////////////////////////////////////////
public abstract Vector2 Position {get; set;}
////////////////////////////////////////////////////////////
/// <summary>
/// Rotation of the object, defined in degrees
/// </summary>
////////////////////////////////////////////////////////////
public abstract float Rotation {get; set;}
////////////////////////////////////////////////////////////
/// <summary>
/// Vertical and horizontal scale of the object
/// </summary>
////////////////////////////////////////////////////////////
public abstract Vector2 Scale {get; set;}
////////////////////////////////////////////////////////////
/// <summary>
/// Origin of the transformation of the object
/// (center of translation, rotation and scale)
/// </summary>
////////////////////////////////////////////////////////////
public abstract Vector2 Origin {get; set;}
////////////////////////////////////////////////////////////
/// <summary>
/// Global color of the object
/// </summary>
////////////////////////////////////////////////////////////
public abstract Color Color {get; set;}
////////////////////////////////////////////////////////////
/// <summary>
/// Blending mode of the object
/// </summary>
////////////////////////////////////////////////////////////
public abstract BlendMode BlendMode {get; set;}
////////////////////////////////////////////////////////////
/// <summary>
/// Transform a point from global coordinates into local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
/// </summary>
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public abstract Vector2 TransformToLocal(Vector2 point);
////////////////////////////////////////////////////////////
/// <summary>
/// Transform a point from local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
/// </summary>
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public abstract Vector2 TransformToGlobal(Vector2 point);
////////////////////////////////////////////////////////////
/// <summary>
/// Render the object into the given render window
/// </summary>
/// <param name="target">Target render window</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
internal abstract void Render(RenderWindow target, Shader shader);
////////////////////////////////////////////////////////////
/// <summary>
/// Render the object into the given render image
/// </summary>
/// <param name="target">Target render image</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
internal abstract void Render(RenderImage target, Shader shader);
////////////////////////////////////////////////////////////
/// <summary>
/// Internal constructor, for derived classes
/// </summary>
/// <param name="thisPtr">Pointer to the object in C library</param>
////////////////////////////////////////////////////////////
protected Drawable(IntPtr thisPtr) :
base(thisPtr)
{
}
}
}
}

238
bindings/dotnet/src/Graphics/Font.cs Normal file
View file

@ -0,0 +1,238 @@
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Security;
using System.IO;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Structure describing a glyph (a visual character)
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct Glyph
{
/// <summary>Offset to move horizontically to the next character</summary>
public int Advance;
/// <summary>Bounding rectangle of the glyph, in coordinates relative to the baseline</summary>
public IntRect Rectangle;
/// <summary>Texture coordinates of the glyph inside the font's image</summary>
public FloatRect TexCoords;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Font is the low-level class for loading and
/// manipulating character fonts. This class is meant to
/// be used by String2D
/// </summary>
////////////////////////////////////////////////////////////
public class Font : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the font from a file
/// </summary>
/// <param name="filename">Font file to load</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Font(string filename) :
base(sfFont_CreateFromFile(filename))
{
if (This == IntPtr.Zero)
throw new LoadingFailedException("font", filename);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the font from a file in a stream
/// </summary>
/// <param name="stream">Stream containing the file contents</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Font(Stream stream) :
base(IntPtr.Zero)
{
unsafe
{
stream.Position = 0;
byte[] StreamData = new byte[stream.Length];
uint Read = (uint)stream.Read(StreamData, 0, StreamData.Length);
fixed (byte* dataPtr = StreamData)
{
SetThis(sfFont_CreateFromMemory((char*)dataPtr, Read));
}
}
if (This == IntPtr.Zero)
throw new LoadingFailedException("font");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the font from another font
/// </summary>
/// <param name="copy">Font to copy</param>
////////////////////////////////////////////////////////////
public Font(Font copy) :
base(sfFont_Copy(copy.This))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get a glyph in the font
/// </summary>
/// <param name="codePoint">Unicode code point of the character to get</param>
/// <param name="characterSize">Character size</param>
/// <param name="bold">Retrieve the bold version or the regular one?</param>
/// <returns>The glyph corresponding to the character</returns>
////////////////////////////////////////////////////////////
public Glyph GetGlyph(uint codePoint, uint characterSize, bool bold)
{
return sfFont_GetGlyph(This, codePoint, characterSize, bold);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the kerning offset between two glyphs
/// </summary>
/// <param name="first">Unicode code point of the first character</param>
/// <param name="second">Unicode code point of the second character</param>
/// <param name="characterSize">Character size</param>
/// <returns>Kerning offset, in pixels</returns>
////////////////////////////////////////////////////////////
public int GetKerning(uint first, uint second, uint characterSize)
{
return sfFont_GetKerning(This, first, second, characterSize);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get spacing between two consecutive lines
/// </summary>
/// <param name="characterSize">Character size</param>
/// <returns>Line spacing, in pixels</returns>
////////////////////////////////////////////////////////////
public int GetLineSpacing(uint characterSize)
{
return sfFont_GetLineSpacing(This, characterSize);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the image containing the glyphs of a given size
/// </summary>
/// <param name="characterSize">Character size</param>
/// <returns>Image storing the glyphs for the given size</returns>
////////////////////////////////////////////////////////////
public Image GetImage(uint characterSize)
{
myImages[characterSize] = new Image(sfFont_GetImage(This, characterSize));
return myImages[characterSize];
}
////////////////////////////////////////////////////////////
/// <summary>
/// Default built-in font
/// </summary>
////////////////////////////////////////////////////////////
public static Font DefaultFont
{
get
{
if (ourDefaultFont == null)
ourDefaultFont = new Font(sfFont_GetDefaultFont());
return ourDefaultFont;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Font]";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
if (this != ourDefaultFont)
{
if (!disposing)
Context.Global.SetActive(true);
sfFont_Destroy(This);
if (disposing)
{
foreach (Image image in myImages.Values)
image.Dispose();
}
if (!disposing)
Context.Global.SetActive(false);
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Internal constructor
/// </summary>
/// <param name="thisPtr">Pointer to the object in C library</param>
////////////////////////////////////////////////////////////
private Font(IntPtr thisPtr) :
base(thisPtr)
{
}
private Dictionary<uint, Image> myImages = new Dictionary<uint, Image>();
private static Font ourDefaultFont = null;
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfFont_CreateFromFile(string Filename);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern IntPtr sfFont_CreateFromMemory(char* Data, uint SizeInBytes);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfFont_Copy(IntPtr Font);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfFont_Destroy(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Glyph sfFont_GetGlyph(IntPtr This, uint codePoint, uint characterSize, bool bold);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern int sfFont_GetKerning(IntPtr This, uint first, uint second, uint characterSize);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern int sfFont_GetLineSpacing(IntPtr This, uint characterSize);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfFont_GetImage(IntPtr This, uint characterSize);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfFont_GetDefaultFont();
#endregion
}
}
}

472
bindings/dotnet/src/Graphics/Image.cs Normal file
View file

@ -0,0 +1,472 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.IO;
using System.Runtime.ConstrainedExecution;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Image is the low-level class for loading and
/// manipulating images
/// </summary>
////////////////////////////////////////////////////////////
public class Image : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor (invalid image)
/// </summary>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Image() :
base(sfImage_Create())
{
if (This == IntPtr.Zero)
throw new LoadingFailedException("image");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the image with black color
/// </summary>
/// <param name="width">Image width</param>
/// <param name="height">Image height</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Image(uint width, uint height) :
this(width, height, Color.Black)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the image from a single color
/// </summary>
/// <param name="width">Image width</param>
/// <param name="height">Image height</param>
/// <param name="color">Color to fill the image with</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Image(uint width, uint height, Color color) :
base(sfImage_CreateFromColor(width, height, color))
{
if (This == IntPtr.Zero)
throw new LoadingFailedException("image");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the image from a file
/// </summary>
/// <param name="filename">Path of the image file to load</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Image(string filename) :
base(sfImage_CreateFromFile(filename))
{
if (This == IntPtr.Zero)
throw new LoadingFailedException("image", filename);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the image from a file in a stream
/// </summary>
/// <param name="stream">Stream containing the file contents</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Image(Stream stream) :
base(IntPtr.Zero)
{
stream.Position = 0;
byte[] StreamData = new byte[stream.Length];
uint Read = (uint)stream.Read(StreamData, 0, StreamData.Length);
unsafe
{
fixed (byte* dataPtr = StreamData)
{
SetThis(sfImage_CreateFromMemory((char*)dataPtr, Read));
}
}
if (This == IntPtr.Zero)
throw new LoadingFailedException("image");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the image directly from an array of pixels
/// </summary>
/// <param name="pixels">2 dimensions array containing the pixels</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Image(Color[,] pixels) :
base(IntPtr.Zero)
{
unsafe
{
fixed (Color* PixelsPtr = pixels)
{
uint Width = (uint)pixels.GetLength(0);
uint Height = (uint)pixels.GetLength(1);
SetThis(sfImage_CreateFromPixels(Width, Height, (byte*)PixelsPtr));
}
}
if (This == IntPtr.Zero)
throw new LoadingFailedException("image");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the image directly from an array of pixels
/// </summary>
/// <param name="width">Image width</param>
/// <param name="height">Image height</param>
/// <param name="pixels">array containing the pixels</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Image(uint width, uint height, byte[] pixels) :
base(IntPtr.Zero)
{
unsafe
{
fixed (byte* PixelsPtr = pixels)
{
SetThis(sfImage_CreateFromPixels(width, height, PixelsPtr));
}
}
if (This == IntPtr.Zero)
throw new LoadingFailedException("image");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the image from another image
/// </summary>
/// <param name="copy">Image to copy</param>
////////////////////////////////////////////////////////////
public Image(Image copy) :
base(sfImage_Copy(copy.This))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Save the contents of the image to a file
/// </summary>
/// <param name="filename">Path of the file to save (overwritten if already exist)</param>
/// <returns>True if saving was successful</returns>
////////////////////////////////////////////////////////////
public bool SaveToFile(string filename)
{
return sfImage_SaveToFile(This, filename);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create a transparency mask from a specified colorkey
/// </summary>
/// <param name="color">Color to become transparent</param>
////////////////////////////////////////////////////////////
public void CreateMaskFromColor(Color color)
{
CreateMaskFromColor(color, 0);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create a transparency mask from a specified colorkey
/// </summary>
/// <param name="color">Color to become transparent</param>
/// <param name="alpha">Alpha value to use for transparent pixels</param>
////////////////////////////////////////////////////////////
public void CreateMaskFromColor(Color color, byte alpha)
{
sfImage_CreateMaskFromColor(This, color, alpha);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Copy pixels from another image onto this one.
/// This function does a slow pixel copy and should only
/// be used at initialization time
/// </summary>
/// <param name="source">Source image to copy</param>
/// <param name="destX">X coordinate of the destination position</param>
/// <param name="destY">Y coordinate of the destination position</param>
////////////////////////////////////////////////////////////
public void Copy(Image source, uint destX, uint destY)
{
Copy(source, destX, destY, new IntRect(0, 0, 0, 0));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Copy pixels from another image onto this one.
/// This function does a slow pixel copy and should only
/// be used at initialization time
/// </summary>
/// <param name="source">Source image to copy</param>
/// <param name="destX">X coordinate of the destination position</param>
/// <param name="destY">Y coordinate of the destination position</param>
/// <param name="sourceRect">Sub-rectangle of the source image to copy</param>
////////////////////////////////////////////////////////////
public void Copy(Image source, uint destX, uint destY, IntRect sourceRect)
{
sfImage_CopyImage(This, source.This, destX, destY, sourceRect);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the image from the current contents of the
/// given window
/// </summary>
/// <param name="window">Window to capture</param>
/// <returns>True if copy has been successful</returns>
////////////////////////////////////////////////////////////
public bool CopyScreen(RenderWindow window)
{
return CopyScreen(window, new IntRect(0, 0, 0, 0));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the image from the current contents of the
/// given window
/// </summary>
/// <param name="window">Window to capture</param>
/// <param name="sourceRect">Sub-rectangle of the screen to copy</param>
/// <returns>True if copy has been successful</returns>
////////////////////////////////////////////////////////////
public bool CopyScreen(RenderWindow window, IntRect sourceRect)
{
return sfImage_CopyScreen(This, window.This, sourceRect);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get a pixel from the image
/// </summary>
/// <param name="x">X coordinate of pixel in the image</param>
/// <param name="y">Y coordinate of pixel in the image</param>
/// <returns>Color of pixel (x, y)</returns>
////////////////////////////////////////////////////////////
public Color GetPixel(uint x, uint y)
{
return sfImage_GetPixel(This, x, y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the color of a pixel
/// </summary>
/// <param name="x">X coordinate of pixel in the image</param>
/// <param name="y">Y coordinate of pixel in the image</param>
/// <param name="color">New color for pixel (x, y)</param>
////////////////////////////////////////////////////////////
public void SetPixel(uint x, uint y, Color color)
{
sfImage_SetPixel(This, x, y, color);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get a copy of the array of pixels (RGBA 8 bits integers components)
/// Array size is Width x Height x 4
/// </summary>
/// <returns>Array of pixels</returns>
////////////////////////////////////////////////////////////
public byte[] Pixels
{
get
{
byte[] PixelsPtr = new byte[Width * Height * 4];
Marshal.Copy(sfImage_GetPixelsPtr(This), PixelsPtr, 0, PixelsPtr.Length);
return PixelsPtr;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Update the pixels of the image
/// </summary>
/// <param name="pixels">2 dimensions array containing the pixels</param>
////////////////////////////////////////////////////////////
public void UpdatePixels(Color[,] pixels)
{
UpdatePixels(pixels, 0, 0);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Update the pixels of the image
/// </summary>
/// <param name="pixels">2 dimensions array containing the pixels</param>
/// <param name="x">X position of the rectangle to update</param>
/// <param name="y">Y position of the rectangle to update</param>
////////////////////////////////////////////////////////////
public void UpdatePixels(Color[,] pixels, uint x, uint y)
{
unsafe
{
fixed (Color* PixelsPtr = pixels)
{
int Width = pixels.GetLength(0);
int Height = pixels.GetLength(1);
sfImage_UpdatePixels(This, PixelsPtr, new IntRect((int)x, (int)y, Width, Height));
}
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Bind the image for rendering
/// </summary>
////////////////////////////////////////////////////////////
public void Bind()
{
sfImage_Bind(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Control the smooth filter
/// </summary>
////////////////////////////////////////////////////////////
public bool Smooth
{
get {return sfImage_IsSmooth(This);}
set {sfImage_SetSmooth(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Width of the image, in pixels
/// </summary>
////////////////////////////////////////////////////////////
public uint Width
{
get {return sfImage_GetWidth(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Height of the image, in pixels
/// </summary>
////////////////////////////////////////////////////////////
public uint Height
{
get {return sfImage_GetHeight(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Image]" +
" Width(" + Width + ")" +
" Height(" + Height + ")" +
" Smooth(" + Smooth + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Internal constructor
/// </summary>
/// <param name="thisPtr">Pointer to the object in C library</param>
////////////////////////////////////////////////////////////
internal Image(IntPtr thisPtr) :
base(thisPtr)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
if (!disposing)
Context.Global.SetActive(true);
sfImage_Destroy(This);
if (!disposing)
Context.Global.SetActive(false);
}
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfImage_Create();
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfImage_CreateFromColor(uint Width, uint Height, Color Col);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern IntPtr sfImage_CreateFromPixels(uint Width, uint Height, byte* Pixels);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfImage_CreateFromFile(string Filename);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfImage_Copy(IntPtr Image);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern IntPtr sfImage_CreateFromMemory(char* Data, uint Size);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfImage_Destroy(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfImage_SaveToFile(IntPtr This, string Filename);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfImage_CreateMaskFromColor(IntPtr This, Color Col, byte Alpha);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfImage_CopyScreen(IntPtr This, IntPtr Window, IntRect SourceRect);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfImage_CopyImage(IntPtr This, IntPtr Source, uint DestX, uint DestY, IntRect SourceRect);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfImage_SetPixel(IntPtr This, uint X, uint Y, Color Col);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Color sfImage_GetPixel(IntPtr This, uint X, uint Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfImage_GetPixelsPtr(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern void sfImage_UpdatePixels(IntPtr This, Color* Pixels, IntRect Rectangle);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfImage_Bind(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfImage_SetSmooth(IntPtr This, bool Smooth);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfImage_GetWidth(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfImage_GetHeight(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfImage_IsSmooth(IntPtr This);
#endregion
}
}
}

247
bindings/dotnet/src/Graphics/Rect.cs Normal file
View file

@ -0,0 +1,247 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// IntRect is an utility class for manipulating 2D rectangles
/// with integer coordinates
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct IntRect
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the rectangle from its coordinates
/// </summary>
/// <param name="left">Left coordinate of the rectangle</param>
/// <param name="top">Top coordinate of the rectangle</param>
/// <param name="width">Width of the rectangle</param>
/// <param name="height">Height of the rectangle</param>
////////////////////////////////////////////////////////////
public IntRect(int left, int top, int width, int height)
{
Left = left;
Top = top;
Width = width;
Height = height;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Check if a point is inside the rectangle's area
/// </summary>
/// <param name="x">X coordinate of the point to test</param>
/// <param name="y">Y coordinate of the point to test</param>
/// <returns>True if the point is inside</returns>
////////////////////////////////////////////////////////////
public bool Contains(int x, int y)
{
return (x >= Left) && (x < Left + Width) && (y >= Top) && (y < Top + Height);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Check intersection between two rectangles
/// </summary>
/// <param name="rect"> Rectangle to test</param>
/// <returns>True if rectangles overlap</returns>
////////////////////////////////////////////////////////////
public bool Intersects(IntRect rect)
{
// Compute the intersection boundaries
int left = Math.Max(Left, rect.Left);
int top = Math.Max(Top, rect.Top);
int right = Math.Min(Left + Width, rect.Left + rect.Width);
int bottom = Math.Min(Top + Height, rect.Top + rect.Height);
return (left < right) && (top < bottom);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Check intersection between two rectangles
/// </summary>
/// <param name="rect"> Rectangle to test</param>
/// <param name="overlap">Rectangle to be filled with overlapping rect</param>
/// <returns>True if rectangles overlap</returns>
////////////////////////////////////////////////////////////
public bool Intersects(IntRect rect, out IntRect overlap)
{
// Compute the intersection boundaries
int left = Math.Max(Left, rect.Left);
int top = Math.Max(Top, rect.Top);
int right = Math.Min(Left + Width, rect.Left + rect.Width);
int bottom = Math.Min(Top + Height, rect.Top + rect.Height);
// If the intersection is valid (positive non zero area), then there is an intersection
if ((left < right) && (top < bottom))
{
overlap.Left = left;
overlap.Top = top;
overlap.Width = right - left;
overlap.Height = bottom - top;
return true;
}
else
{
overlap.Left = 0;
overlap.Top = 0;
overlap.Width = 0;
overlap.Height = 0;
return false;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[IntRect]" +
" Left(" + Left + ")" +
" Top(" + Top + ")" +
" Width(" + Width + ")" +
" Height(" + Height + ")";
}
/// <summary>Left coordinate of the rectangle</summary>
public int Left;
/// <summary>Top coordinate of the rectangle</summary>
public int Top;
/// <summary>Width of the rectangle</summary>
public int Width;
/// <summary>Height of the rectangle</summary>
public int Height;
}
////////////////////////////////////////////////////////////
/// <summary>
/// IntRect is an utility class for manipulating 2D rectangles
/// with float coordinates
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct FloatRect
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the rectangle from its coordinates
/// </summary>
/// <param name="left">Left coordinate of the rectangle</param>
/// <param name="top">Top coordinate of the rectangle</param>
/// <param name="width">Width of the rectangle</param>
/// <param name="height">Height of the rectangle</param>
////////////////////////////////////////////////////////////
public FloatRect(float left, float top, float width, float height)
{
Left = left;
Top = top;
Width = width;
Height = height;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Check if a point is inside the rectangle's area
/// </summary>
/// <param name="x">X coordinate of the point to test</param>
/// <param name="y">Y coordinate of the point to test</param>
/// <returns>True if the point is inside</returns>
////////////////////////////////////////////////////////////
public bool Contains(float x, float y)
{
return (x >= Left) && (x < Left + Width) && (y >= Top) && (y < Top + Height);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Check intersection between two rectangles
/// </summary>
/// <param name="rect"> Rectangle to test</param>
/// <returns>True if rectangles overlap</returns>
////////////////////////////////////////////////////////////
public bool Intersects(FloatRect rect)
{
// Compute the intersection boundaries
float left = Math.Max(Left, rect.Left);
float top = Math.Max(Top, rect.Top);
float right = Math.Min(Left + Width, rect.Left + rect.Width);
float bottom = Math.Min(Top + Height, rect.Top + rect.Height);
return (left < right) && (top < bottom);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Check intersection between two rectangles
/// </summary>
/// <param name="rect"> Rectangle to test</param>
/// <param name="overlap">Rectangle to be filled with overlapping rect</param>
/// <returns>True if rectangles overlap</returns>
////////////////////////////////////////////////////////////
public bool Intersects(FloatRect rect, out FloatRect overlap)
{
// Compute the intersection boundaries
float left = Math.Max(Left, rect.Left);
float top = Math.Max(Top, rect.Top);
float right = Math.Min(Left + Width, rect.Left + rect.Width);
float bottom = Math.Min(Top + Height, rect.Top + rect.Height);
// If the intersection is valid (positive non zero area), then there is an intersection
if ((left < right) && (top < bottom))
{
overlap.Left = left;
overlap.Top = top;
overlap.Width = right - left;
overlap.Height = bottom - top;
return true;
}
else
{
overlap.Left = 0;
overlap.Top = 0;
overlap.Width = 0;
overlap.Height = 0;
return false;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[FloatRect]" +
" Left(" + Left + ")" +
" Top(" + Top + ")" +
" Width(" + Width + ")" +
" Height(" + Height + ")";
}
/// <summary>Left coordinate of the rectangle</summary>
public float Left;
/// <summary>Top coordinate of the rectangle</summary>
public float Top;
/// <summary>Width of the rectangle</summary>
public float Width;
/// <summary>Height of the rectangle</summary>
public float Height;
}
}
}

340
bindings/dotnet/src/Graphics/RenderImage.cs Normal file
View file

@ -0,0 +1,340 @@
using System;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Generic;
using System.Security;
using SFML.Window;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Simple wrapper for Window that allows easy
/// 2D rendering
/// </summary>
////////////////////////////////////////////////////////////
public class RenderImage : ObjectBase, RenderTarget
{
////////////////////////////////////////////////////////////
/// <summary>
/// Create the render image with the given dimensions
/// </summary>
/// <param name="width">Width of the render image</param>
/// <param name="height">Height of the render image</param>
////////////////////////////////////////////////////////////
public RenderImage(uint width, uint height) :
this(width, height, false)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the render image with the given dimensions and
/// an optional depth-buffer attached
/// </summary>
/// <param name="width">Width of the render image</param>
/// <param name="height">Height of the render image</param>
/// <param name="depthBuffer">Do you want a depth-buffer attached?</param>
////////////////////////////////////////////////////////////
public RenderImage(uint width, uint height, bool depthBuffer) :
base(sfRenderImage_Create(width, height, depthBuffer))
{
myDefaultView = new View(sfRenderImage_GetDefaultView(This));
myImage = new Image(sfRenderImage_GetImage(This));
myCurrentView = myDefaultView;
GC.SuppressFinalize(myDefaultView);
GC.SuppressFinalize(myImage);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Width of the rendering region of the image
/// </summary>
////////////////////////////////////////////////////////////
public uint Width
{
get {return sfRenderImage_GetWidth(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Height of the rendering region of the image
/// </summary>
////////////////////////////////////////////////////////////
public uint Height
{
get {return sfRenderImage_GetHeight(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Activate of deactivate the render image as the current target
/// for rendering
/// </summary>
/// <param name="active">True to activate, false to deactivate (true by default)</param>
/// <returns>True if operation was successful, false otherwise</returns>
////////////////////////////////////////////////////////////
public bool SetActive(bool active)
{
return sfRenderImage_SetActive(This, active);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Default view of the render image
/// </summary>
////////////////////////////////////////////////////////////
public View DefaultView
{
get {return myDefaultView;}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Current view active in the render image
/// </summary>
////////////////////////////////////////////////////////////
public View CurrentView
{
get {return myCurrentView;}
set {myCurrentView = value; sfRenderImage_SetView(This, value.This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the viewport of a view applied to this target
/// </summary>
/// <param name="view">Target view</param>
/// <returns>Viewport rectangle, expressed in pixels in the current target</returns>
////////////////////////////////////////////////////////////
public IntRect GetViewport(View view)
{
return sfRenderImage_GetViewport(This, view.This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Convert a point in target coordinates into view coordinates
/// This version uses the current view of the window
/// </summary>
/// <param name="x">X coordinate of the point to convert, relative to the target</param>
/// <param name="y">Y coordinate of the point to convert, relative to the target</param>
/// <returns>Converted point</returns>
///
////////////////////////////////////////////////////////////
public Vector2 ConvertCoords(uint x, uint y)
{
return ConvertCoords(x, y, CurrentView);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Convert a point in target coordinates into view coordinates
/// This version uses the given view
/// </summary>
/// <param name="x">X coordinate of the point to convert, relative to the target</param>
/// <param name="y">Y coordinate of the point to convert, relative to the target</param>
/// <param name="view">Target view to convert the point to</param>
/// <returns>Converted point</returns>
///
////////////////////////////////////////////////////////////
public Vector2 ConvertCoords(uint x, uint y, View view)
{
Vector2 point;
sfRenderImage_ConvertCoords(This, x, y, out point.X, out point.Y, view.This);
return point;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Clear the entire render image with black color
/// </summary>
////////////////////////////////////////////////////////////
public void Clear()
{
sfRenderImage_Clear(This, Color.Black);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Clear the entire render image with a single color
/// </summary>
/// <param name="color">Color to use to clear the image</param>
////////////////////////////////////////////////////////////
public void Clear(Color color)
{
sfRenderImage_Clear(This, color);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Draw something into the render image
/// </summary>
/// <param name="objectToDraw">Object to draw</param>
////////////////////////////////////////////////////////////
public void Draw(Drawable objectToDraw)
{
objectToDraw.Render(this, null);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Draw something into the render image with a shader
/// </summary>
/// <param name="objectToDraw">Object to draw</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
public void Draw(Drawable objectToDraw, Shader shader)
{
objectToDraw.Render(this, shader);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Save the current OpenGL render states and matrices
/// </summary>
////////////////////////////////////////////////////////////
public void SaveGLStates()
{
sfRenderImage_SaveGLStates(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Restore the previously saved OpenGL render states and matrices
/// </summary>
////////////////////////////////////////////////////////////
public void RestoreGLStates()
{
sfRenderImage_RestoreGLStates(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Update the contents of the target image
/// </summary>
////////////////////////////////////////////////////////////
public void Display()
{
sfRenderImage_Display(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Target image of the render image
/// </summary>
////////////////////////////////////////////////////////////
public Image Image
{
get {return myImage;}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Tell whether or not the system supports render images
/// </summary>
////////////////////////////////////////////////////////////
public static bool IsAvailable
{
get {return sfRenderImage_IsAvailable();}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[RenderImage]" +
" Width(" + Width + ")" +
" Height(" + Height + ")" +
" Image(" + Image + ")" +
" DefaultView(" + DefaultView + ")" +
" CurrentView(" + CurrentView + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
if (!disposing)
Context.Global.SetActive(true);
sfRenderImage_Destroy(This);
if (disposing)
{
myDefaultView.Dispose();
myImage.Dispose();
}
if (!disposing)
Context.Global.SetActive(false);
}
private View myCurrentView = null;
private View myDefaultView = null;
private Image myImage = null;
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderImage_Create(uint Width, uint Height, bool DepthBuffer);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_Destroy(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_Clear(IntPtr This, Color ClearColor);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfRenderImage_GetWidth(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfRenderImage_GetHeight(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderImage_SetActive(IntPtr This, bool Active);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderImage_SaveGLStates(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderImage_RestoreGLStates(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderImage_Display(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_SetView(IntPtr This, IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderImage_GetView(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderImage_GetDefaultView(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntRect sfRenderImage_GetViewport(IntPtr This, IntPtr TargetView);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_ConvertCoords(IntPtr This, uint WindowX, uint WindowY, out float ViewX, out float ViewY, IntPtr TargetView);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderImage_GetImage(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderImage_IsAvailable();
#endregion
}
}
}

124
bindings/dotnet/src/Graphics/RenderTarget.cs Normal file
View file

@ -0,0 +1,124 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using SFML.Window;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Abstract base class for render targets (renderwindow, renderimage)
/// </summary>
////////////////////////////////////////////////////////////
public interface RenderTarget
{
////////////////////////////////////////////////////////////
/// <summary>
/// Width of the rendering region of the window
/// </summary>
////////////////////////////////////////////////////////////
uint Width {get;}
////////////////////////////////////////////////////////////
/// <summary>
/// Height of the rendering region of the window
/// </summary>
////////////////////////////////////////////////////////////
uint Height {get;}
////////////////////////////////////////////////////////////
/// <summary>
/// Default view of the window
/// </summary>
////////////////////////////////////////////////////////////
View DefaultView {get;}
////////////////////////////////////////////////////////////
/// <summary>
/// Current view active in the window
/// </summary>
////////////////////////////////////////////////////////////
View CurrentView {get;}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the viewport of a view applied to this target
/// </summary>
/// <param name="view">Target view</param>
/// <returns>Viewport rectangle, expressed in pixels in the current target</returns>
////////////////////////////////////////////////////////////
IntRect GetViewport(View view);
////////////////////////////////////////////////////////////
/// <summary>
/// Convert a point in target coordinates into view coordinates
/// This version uses the current view of the window
/// </summary>
/// <param name="x">X coordinate of the point to convert, relative to the target</param>
/// <param name="y">Y coordinate of the point to convert, relative to the target</param>
/// <returns>Converted point</returns>
////////////////////////////////////////////////////////////
Vector2 ConvertCoords(uint x, uint y);
////////////////////////////////////////////////////////////
/// <summary>
/// Convert a point in target coordinates into view coordinates
/// This version uses the given view
/// </summary>
/// <param name="x">X coordinate of the point to convert, relative to the target</param>
/// <param name="y">Y coordinate of the point to convert, relative to the target</param>
/// <param name="view">Target view to convert the point to</param>
/// <returns>Converted point</returns>
////////////////////////////////////////////////////////////
Vector2 ConvertCoords(uint x, uint y, View view);
////////////////////////////////////////////////////////////
/// <summary>
/// Clear the entire window with black color
/// </summary>
////////////////////////////////////////////////////////////
void Clear();
////////////////////////////////////////////////////////////
/// <summary>
/// Clear the entire window with a single color
/// </summary>
/// <param name="color">Color to use to clear the window</param>
////////////////////////////////////////////////////////////
void Clear(Color color);
////////////////////////////////////////////////////////////
/// <summary>
/// Draw something into the window
/// </summary>
/// <param name="objectToDraw">Object to draw</param>
////////////////////////////////////////////////////////////
void Draw(Drawable objectToDraw);
////////////////////////////////////////////////////////////
/// <summary>
/// Draw something into the render image with a shader
/// </summary>
/// <param name="objectToDraw">Object to draw</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
void Draw(Drawable objectToDraw, Shader shader);
////////////////////////////////////////////////////////////
/// <summary>
/// Save the current OpenGL render states and matrices
/// </summary>
////////////////////////////////////////////////////////////
void SaveGLStates();
////////////////////////////////////////////////////////////
/// <summary>
/// Restore the previously saved OpenGL render states and matrices
/// </summary>
////////////////////////////////////////////////////////////
void RestoreGLStates();
}
}
}

611
bindings/dotnet/src/Graphics/RenderWindow.cs Normal file
View file

@ -0,0 +1,611 @@
using System;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Generic;
using System.Security;
using SFML.Window;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Simple wrapper for Window that allows easy
/// 2D rendering
/// </summary>
////////////////////////////////////////////////////////////
public class RenderWindow : SFML.Window.Window, RenderTarget
{
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window with default style and creation settings
/// </summary>
/// <param name="mode">Video mode to use</param>
/// <param name="title">Title of the window</param>
////////////////////////////////////////////////////////////
public RenderWindow(VideoMode mode, string title) :
this(mode, title, Styles.Default, new ContextSettings(24, 8))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window with default creation settings
/// </summary>
/// <param name="mode">Video mode to use</param>
/// <param name="title">Title of the window</param>
/// <param name="style">Window style (Resize | Close by default)</param>
////////////////////////////////////////////////////////////
public RenderWindow(VideoMode mode, string title, Styles style) :
this(mode, title, style, new ContextSettings(24, 8))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window
/// </summary>
/// <param name="mode">Video mode to use</param>
/// <param name="title">Title of the window</param>
/// <param name="style">Window style (Resize | Close by default)</param>
/// <param name="settings">Creation parameters</param>
////////////////////////////////////////////////////////////
public RenderWindow(VideoMode mode, string title, Styles style, ContextSettings settings) :
base(sfRenderWindow_Create(mode, title, style, ref settings), 0)
{
Initialize();
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window from an existing control with default creation settings
/// </summary>
/// <param name="handle">Platform-specific handle of the control</param>
////////////////////////////////////////////////////////////
public RenderWindow(IntPtr handle) :
this(handle, new ContextSettings(24, 8))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window from an existing control
/// </summary>
/// <param name="handle">Platform-specific handle of the control</param>
/// <param name="settings">Creation parameters</param>
////////////////////////////////////////////////////////////
public RenderWindow(IntPtr handle, ContextSettings settings) :
base(sfRenderWindow_CreateFromHandle(handle, ref settings), 0)
{
Initialize();
}
////////////////////////////////////////////////////////////
/// <summary>
/// Tell whether or not the window is opened (ie. has been created).
/// Note that a hidden window (Show(false))
/// will still return true
/// </summary>
/// <returns>True if the window is opened</returns>
////////////////////////////////////////////////////////////
public override bool IsOpened()
{
return sfRenderWindow_IsOpened(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Close (destroy) the window.
/// The Window instance remains valid and you can call
/// Create to recreate the window
/// </summary>
////////////////////////////////////////////////////////////
public override void Close()
{
sfRenderWindow_Close(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Display the window on screen
/// </summary>
////////////////////////////////////////////////////////////
public override void Display()
{
sfRenderWindow_Display(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Width of the rendering region of the window
/// </summary>
////////////////////////////////////////////////////////////
public override uint Width
{
get {return sfRenderWindow_GetWidth(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Height of the rendering region of the window
/// </summary>
////////////////////////////////////////////////////////////
public override uint Height
{
get {return sfRenderWindow_GetHeight(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Creation settings of the window
/// </summary>
////////////////////////////////////////////////////////////
public override ContextSettings Settings
{
get {return sfRenderWindow_GetSettings(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Enable / disable vertical synchronization
/// </summary>
/// <param name="enable">True to enable v-sync, false to deactivate</param>
////////////////////////////////////////////////////////////
public override void UseVerticalSync(bool enable)
{
sfRenderWindow_UseVerticalSync(This, enable);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Show or hide the mouse cursor
/// </summary>
/// <param name="show">True to show, false to hide</param>
////////////////////////////////////////////////////////////
public override void ShowMouseCursor(bool show)
{
sfRenderWindow_ShowMouseCursor(This, show);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the position of the mouse cursor
/// </summary>
/// <param name="x">Left coordinate of the cursor, relative to the window</param>
/// <param name="y">Top coordinate of the cursor, relative to the window</param>
////////////////////////////////////////////////////////////
public override void SetCursorPosition(uint x, uint y)
{
sfRenderWindow_SetCursorPosition(This, x, y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the position of the window on screen.
/// Only works for top-level windows
/// </summary>
/// <param name="x">Left position</param>
/// <param name="y">Top position</param>
////////////////////////////////////////////////////////////
public override void SetPosition(int x, int y)
{
sfRenderWindow_SetPosition(This, x, y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the size of the rendering region of the window
/// </summary>
/// <param name="width">New width</param>
/// <param name="height">New height</param>
////////////////////////////////////////////////////////////
public override void SetSize(uint width, uint height)
{
sfRenderWindow_SetSize(This, width, height);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Show or hide the window
/// </summary>
/// <param name="show">True to show, false to hide</param>
////////////////////////////////////////////////////////////
public override void Show(bool show)
{
sfRenderWindow_Show(This, show);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Enable or disable automatic key-repeat.
/// Automatic key-repeat is enabled by default
/// </summary>
/// <param name="enable">True to enable, false to disable</param>
////////////////////////////////////////////////////////////
public override void EnableKeyRepeat(bool enable)
{
sfRenderWindow_EnableKeyRepeat(This, enable);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the window's icon
/// </summary>
/// <param name="width">Icon's width, in pixels</param>
/// <param name="height">Icon's height, in pixels</param>
/// <param name="pixels">Array of pixels, format must be RGBA 32 bits</param>
////////////////////////////////////////////////////////////
public override void SetIcon(uint width, uint height, byte[] pixels)
{
unsafe
{
fixed (byte* PixelsPtr = pixels)
{
sfRenderWindow_SetIcon(This, width, height, PixelsPtr);
}
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Activate of deactivate the window as the current target
/// for rendering
/// </summary>
/// <param name="active">True to activate, false to deactivate (true by default)</param>
/// <returns>True if operation was successful, false otherwise</returns>
////////////////////////////////////////////////////////////
public override bool SetActive(bool active)
{
return sfRenderWindow_SetActive(This, active);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Limit the framerate to a maximum fixed frequency
/// </summary>
/// <param name="limit">Framerate limit, in frames per seconds (use 0 to disable limit)</param>
////////////////////////////////////////////////////////////
public override void SetFramerateLimit(uint limit)
{
sfRenderWindow_SetFramerateLimit(This, limit);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get time elapsed since last frame
/// </summary>
/// <returns>Time elapsed, in seconds</returns>
////////////////////////////////////////////////////////////
public override float GetFrameTime()
{
return sfRenderWindow_GetFrameTime(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the joystick threshold, ie. the value below which
/// no move event will be generated
/// </summary>
/// <param name="threshold">New threshold, in range [0, 100]</param>
////////////////////////////////////////////////////////////
public override void SetJoystickThreshold(float threshold)
{
sfRenderWindow_SetJoystickThreshold(This, threshold);
}
////////////////////////////////////////////////////////////
/// <summary>
/// OS-specific handle of the window
/// </summary>
////////////////////////////////////////////////////////////
public override IntPtr SystemHandle
{
get {return sfRenderWindow_GetSystemHandle(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Default view of the window
/// </summary>
////////////////////////////////////////////////////////////
public View DefaultView
{
get {return myDefaultView;}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Current view active in the window
/// </summary>
////////////////////////////////////////////////////////////
public View CurrentView
{
get {return myCurrentView;}
set {myCurrentView = value; sfRenderWindow_SetView(This, value.This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the viewport of a view applied to this target
/// </summary>
/// <param name="view">Target view</param>
/// <returns>Viewport rectangle, expressed in pixels in the current target</returns>
////////////////////////////////////////////////////////////
public IntRect GetViewport(View view)
{
return sfRenderWindow_GetViewport(This, view.This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Convert a point in target coordinates into view coordinates
/// This version uses the current view of the window
/// </summary>
/// <param name="x">X coordinate of the point to convert, relative to the target</param>
/// <param name="y">Y coordinate of the point to convert, relative to the target</param>
/// <returns>Converted point</returns>
///
////////////////////////////////////////////////////////////
public Vector2 ConvertCoords(uint x, uint y)
{
return ConvertCoords(x, y, CurrentView);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Convert a point in target coordinates into view coordinates
/// This version uses the given view
/// </summary>
/// <param name="x">X coordinate of the point to convert, relative to the target</param>
/// <param name="y">Y coordinate of the point to convert, relative to the target</param>
/// <param name="view">Target view to convert the point to</param>
/// <returns>Converted point</returns>
///
////////////////////////////////////////////////////////////
public Vector2 ConvertCoords(uint x, uint y, View view)
{
Vector2 point;
sfRenderWindow_ConvertCoords(This, x, y, out point.X, out point.Y, view.This);
return point;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Clear the entire window with black color
/// </summary>
////////////////////////////////////////////////////////////
public void Clear()
{
sfRenderWindow_Clear(This, Color.Black);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Clear the entire window with a single color
/// </summary>
/// <param name="color">Color to use to clear the window</param>
////////////////////////////////////////////////////////////
public void Clear(Color color)
{
sfRenderWindow_Clear(This, color);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Draw something into the window
/// </summary>
/// <param name="objectToDraw">Object to draw</param>
////////////////////////////////////////////////////////////
public void Draw(Drawable objectToDraw)
{
objectToDraw.Render(this, null);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Draw something into the window with a shader
/// </summary>
/// <param name="objectToDraw">Object to draw</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
public void Draw(Drawable objectToDraw, Shader shader)
{
objectToDraw.Render(this, shader);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Save the current OpenGL render states and matrices
/// </summary>
////////////////////////////////////////////////////////////
public void SaveGLStates()
{
sfRenderWindow_SaveGLStates(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Restore the previously saved OpenGL render states and matrices
/// </summary>
////////////////////////////////////////////////////////////
public void RestoreGLStates()
{
sfRenderWindow_RestoreGLStates(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[RenderWindow]" +
" Width(" + Width + ")" +
" Height(" + Height + ")" +
" Settings(" + Settings + ")" +
" DefaultView(" + DefaultView + ")" +
" CurrentView(" + CurrentView + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Internal function to get the next event
/// </summary>
/// <param name="eventToFill">Variable to fill with the raw pointer to the event structure</param>
/// <returns>True if there was an event, false otherwise</returns>
////////////////////////////////////////////////////////////
protected override bool GetEvent(out Event eventToFill)
{
return sfRenderWindow_GetEvent(This, out eventToFill);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Internal function to get the next event (blocking)
/// </summary>
/// <param name="eventToFill">Variable to fill with the raw pointer to the event structure</param>
/// <returns>False if any error occured</returns>
////////////////////////////////////////////////////////////
protected override bool WaitEvent(out Event eventToFill)
{
return sfRenderWindow_WaitEvent(This, out eventToFill);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfRenderWindow_Destroy(This);
if (disposing)
myDefaultView.Dispose();
}
////////////////////////////////////////////////////////////
/// <summary>
/// Do common initializations
/// </summary>
////////////////////////////////////////////////////////////
private void Initialize()
{
myInput = new Input(sfRenderWindow_GetInput(This));
myDefaultView = new View(sfRenderWindow_GetDefaultView(This));
myCurrentView = myDefaultView;
GC.SuppressFinalize(myDefaultView);
}
private View myCurrentView = null;
private View myDefaultView = null;
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderWindow_Create(VideoMode Mode, string Title, Styles Style, ref ContextSettings Params);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderWindow_CreateFromHandle(IntPtr Handle, ref ContextSettings Params);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_Destroy(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderWindow_GetInput(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderWindow_IsOpened(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_Close(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderWindow_GetEvent(IntPtr This, out Event Evt);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderWindow_WaitEvent(IntPtr This, out Event Evt);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_Clear(IntPtr This, Color ClearColor);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_Display(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfRenderWindow_GetWidth(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfRenderWindow_GetHeight(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern ContextSettings sfRenderWindow_GetSettings(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_UseVerticalSync(IntPtr This, bool Enable);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_ShowMouseCursor(IntPtr This, bool Show);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_SetCursorPosition(IntPtr This, uint X, uint Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_SetPosition(IntPtr This, int X, int Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_SetSize(IntPtr This, uint Width, uint Height);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_Show(IntPtr This, bool Show);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_EnableKeyRepeat(IntPtr This, bool Enable);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern void sfRenderWindow_SetIcon(IntPtr This, uint Width, uint Height, byte* Pixels);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderWindow_SetActive(IntPtr This, bool Active);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderWindow_SaveGLStates(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderWindow_RestoreGLStates(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_SetFramerateLimit(IntPtr This, uint Limit);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfRenderWindow_GetFrameTime(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_SetJoystickThreshold(IntPtr This, float Threshold);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_SetView(IntPtr This, IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderWindow_GetView(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderWindow_GetDefaultView(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntRect sfRenderWindow_GetViewport(IntPtr This, IntPtr TargetView);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_ConvertCoords(IntPtr This, uint WindowX, uint WindowY, out float ViewX, out float ViewY, IntPtr TargetView);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderWindow_GetSystemHandle(IntPtr This);
#endregion
}
}
}

265
bindings/dotnet/src/Graphics/Shader.cs Normal file
View file

@ -0,0 +1,265 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Collections.Generic;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Wrapper for pixel shaders
/// </summary>
////////////////////////////////////////////////////////////
public class Shader : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor (invalid shader)
/// </summary>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Shader() :
base(sfShader_Create())
{
if (This == IntPtr.Zero)
throw new LoadingFailedException("shader");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Load the shader from a file
/// </summary>
/// <param name="filename">Path of the shader file to load</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
public Shader(string filename) :
base(sfShader_CreateFromFile(filename))
{
if (This == IntPtr.Zero)
throw new LoadingFailedException("shader", filename);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the shader from another shader
/// </summary>
/// <param name="copy">Shader to copy</param>
////////////////////////////////////////////////////////////
public Shader(Shader copy) :
base(sfShader_Copy(copy.This))
{
foreach (KeyValuePair<string, Image> pair in copy.myTextures)
myTextures[pair.Key] = copy.myTextures[pair.Key];
}
////////////////////////////////////////////////////////////
/// <summary>
/// Load the shader from a text in memory
/// </summary>
/// <param name="shader">String containing the shader code</param>
/// <exception cref="LoadingFailedException" />
////////////////////////////////////////////////////////////
void LoadFromString(string shader)
{
SetThis(sfShader_CreateFromMemory(shader));
if (This == IntPtr.Zero)
throw new LoadingFailedException("shader");
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change a vector2 parameter of the shader
/// </summary>
/// <param name="name">Name of the parameter in the shader</param>
/// <param name="v">Value of the parameter</param>
////////////////////////////////////////////////////////////
public void SetParameter(string name, Vector2 v)
{
SetParameter(name, v.X, v.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change a 1-component parameter of the shader
/// </summary>
/// <param name="name">Name of the parameter in the shader</param>
/// <param name="x">Value of the parameter</param>
////////////////////////////////////////////////////////////
public void SetParameter(string name, float x)
{
sfShader_SetParameter1(This, name, x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change a 2-component parameter of the shader
/// </summary>
/// <param name="name">Name of the parameter in the shader</param>
/// <param name="x">X component of the value</param>
/// <param name="y">Y component of the value</param>
////////////////////////////////////////////////////////////
public void SetParameter(string name, float x, float y)
{
sfShader_SetParameter2(This, name, x, y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change a 3-component parameter of the shader
/// </summary>
/// <param name="name">Name of the parameter in the shader</param>
/// <param name="x">X component of the value</param>
/// <param name="y">Y component of the value</param>
/// <param name="z">Z component of the value</param>
////////////////////////////////////////////////////////////
public void SetParameter(string name, float x, float y, float z)
{
sfShader_SetParameter3(This, name, x, y, z);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change a 4-component parameter of the shader
/// </summary>
/// <param name="name">Name of the parameter in the shader</param>
/// <param name="x">X component of the value</param>
/// <param name="y">Y component of the value</param>
/// <param name="z">Z component of the value</param>
/// <param name="w">W component of the value</param>
////////////////////////////////////////////////////////////
public void SetParameter(string name, float x, float y, float z, float w)
{
sfShader_SetParameter4(This, name, x, y, z, w);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Set a texture parameter
/// </summary>
/// <param name="name">Name of the texture in the shader</param>
/// <param name="texture">Image to set (pass null to use the texture of the object being drawn)</param>
////////////////////////////////////////////////////////////
public void SetTexture(string name, Image texture)
{
myTextures[name] = texture;
sfShader_SetTexture(This, name, texture != null ? texture.This : IntPtr.Zero);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Bind the shader for rendering
/// </summary>
////////////////////////////////////////////////////////////
public void Bind()
{
sfShader_Bind(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Unbind the shader
/// </summary>
////////////////////////////////////////////////////////////
public void Unbind()
{
sfShader_Unbind(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Tell whether or not the system supports shaders
/// </summary>
////////////////////////////////////////////////////////////
public static bool IsAvailable
{
get {return sfShader_IsAvailable();}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Special image representing the texture used by the object being drawn
/// </summary>
////////////////////////////////////////////////////////////
public static Image CurrentTexture
{
get {return null;}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Shader]";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
if (!disposing)
Context.Global.SetActive(true);
myTextures.Clear();
sfShader_Destroy(This);
if (!disposing)
Context.Global.SetActive(false);
}
Dictionary<string, Image> myTextures = new Dictionary<string, Image>();
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShader_Create();
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShader_CreateFromFile(string Filename);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShader_CreateFromMemory(string Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShader_Copy(IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShader_Destroy(IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShader_SetParameter1(IntPtr Shader, string Name, float X);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShader_SetParameter2(IntPtr Shader, string Name, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShader_SetParameter3(IntPtr Shader, string Name, float X, float Y, float Z);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShader_SetParameter4(IntPtr Shader, string Name, float X, float Y, float Z, float W);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShader_SetTexture(IntPtr Shader, string Name, IntPtr Texture);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShader_Bind(IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShader_Unbind(IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfShader_IsAvailable();
#endregion
}
}
}

564
bindings/dotnet/src/Graphics/Shape.cs Normal file
View file

@ -0,0 +1,564 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Shape defines a drawable convex shape ; it also defines
/// helper functions to draw simple shapes like
/// lines, rectangles, circles, etc.
/// </summary>
////////////////////////////////////////////////////////////
public class Shape : Drawable
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor
/// </summary>
////////////////////////////////////////////////////////////
public Shape() :
base(sfShape_Create())
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the shape from another shape
/// </summary>
/// <param name="copy">Shape to copy</param>
////////////////////////////////////////////////////////////
public Shape(Shape copy) :
base(sfShape_Copy(copy.This))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Position of the object on screen
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Position
{
get { return new Vector2(sfShape_GetX(This), sfShape_GetY(This)); }
set { sfShape_SetPosition(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Rotation of the object, defined in degrees
/// </summary>
////////////////////////////////////////////////////////////
public override float Rotation
{
get { return sfShape_GetRotation(This); }
set { sfShape_SetRotation(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Vertical and horizontal scale of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Scale
{
get { return new Vector2(sfShape_GetScaleX(This), sfShape_GetScaleY(This)); }
set { sfShape_SetScale(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Origin of the transformation of the object
/// (center of translation, rotation and scale)
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Origin
{
get { return new Vector2(sfShape_GetOriginX(This), sfShape_GetOriginY(This)); }
set { sfShape_SetOrigin(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Global color of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Color Color
{
get { return sfShape_GetColor(This); }
set { sfShape_SetColor(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Blending mode of the object
/// </summary>
////////////////////////////////////////////////////////////
public override BlendMode BlendMode
{
get { return sfShape_GetBlendMode(This); }
set { sfShape_SetBlendMode(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Transform a point from global coordinates into local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
/// </summary>
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToLocal(Vector2 point)
{
Vector2 Transformed;
sfShape_TransformToLocal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Transform a point from local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
/// </summary>
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToGlobal(Vector2 point)
{
Vector2 Transformed;
sfShape_TransformToGlobal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Add a point to the shape
/// </summary>
/// <param name="position">Position of the point</param>
/// <param name="color">Color of the point</param>
////////////////////////////////////////////////////////////
public void AddPoint(Vector2 position, Color color)
{
AddPoint(position, color, Color.Black);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Add a point to the shape
/// </summary>
/// <param name="position">Position of the point</param>
/// <param name="color">Color of the point</param>
/// <param name="outlineColor">Outline color of the point</param>
////////////////////////////////////////////////////////////
public void AddPoint(Vector2 position, Color color, Color outlineColor)
{
sfShape_AddPoint(This, position.X, position.Y, color, outlineColor);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Enable or disable filling the shape.
/// Fill is enabled by default
/// </summary>
/// <param name="enable">True to enable, false to disable</param>
////////////////////////////////////////////////////////////
public void EnableFill(bool enable)
{
sfShape_EnableFill(This, enable);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Enable or disable drawing the shape outline.
/// Outline is enabled by default
/// </summary>
/// <param name="enable">True to enable, false to disable</param>
////////////////////////////////////////////////////////////
public void EnableOutline(bool enable)
{
sfShape_EnableOutline(This, enable);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Width of the shape outline
/// </summary>
////////////////////////////////////////////////////////////
public float OutlineWidth
{
get {return sfShape_GetOutlineWidth(This);}
set {sfShape_SetOutlineWidth(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Total number of points of the shape
/// </summary>
////////////////////////////////////////////////////////////
public uint PointsCount
{
get {return sfShape_GetPointsCount(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Set the position of a point
/// </summary>
/// <param name="index">Index of the point, in range [0, NbPoints - 1]</param>
/// <param name="position">New position of the index-th point</param>
////////////////////////////////////////////////////////////
public void SetPointPosition(uint index, Vector2 position)
{
sfShape_SetPointPosition(This, index, position.X, position.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the position of a point
/// </summary>
/// <param name="index">Index of the point, in range [0, NbPoints - 1]</param>
/// <returns>Position of the index-th point</returns>
////////////////////////////////////////////////////////////
public Vector2 GetPointPosition(uint index)
{
Vector2 Pos;
sfShape_GetPointPosition(This, index, out Pos.X, out Pos.Y);
return Pos;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Set the color of a point
/// </summary>
/// <param name="index">Index of the point, in range [0, NbPoints - 1]</param>
/// <param name="color">New color of the index-th point</param>
////////////////////////////////////////////////////////////
public void SetPointColor(uint index, Color color)
{
sfShape_SetPointColor(This, index, color);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the color of a point
/// </summary>
/// <param name="index">Index of the point, in range [0, NbPoints - 1]</param>
/// <returns>Color of the index-th point</returns>
////////////////////////////////////////////////////////////
public Color GetPointColor(uint index)
{
return sfShape_GetPointColor(This, index);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Set the outline color of a point
/// </summary>
/// <param name="index">Index of the point, in range [0, NbPoints - 1]</param>
/// <param name="color">New outline color of the index-th point</param>
////////////////////////////////////////////////////////////
public void SetPointOutlineColor(uint index, Color color)
{
sfShape_SetPointOutlineColor(This, index, color);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the outline color of a point
/// </summary>
/// <param name="index">Index of the point, in range [0, NbPoints - 1]</param>
/// <returns>Outline color of the index-th point</returns>
////////////////////////////////////////////////////////////
public Color GetPointOutlineColor(uint index)
{
return sfShape_GetPointOutlineColor(This, index);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create a shape made of a single line
/// </summary>
/// <param name="p1">Position of the first point</param>
/// <param name="p2">Position of the second point</param>
/// <param name="thickness">Line thickness</param>
/// <param name="color">Color used to draw the line</param>
/// <returns>New line shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Line(Vector2 p1, Vector2 p2, float thickness, Color color)
{
return Line(p1, p2, thickness, color, 0, Color.White);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create a shape made of a single line
/// </summary>
/// <param name="p1">Position of the first point</param>
/// <param name="p2">Position of the second point</param>
/// <param name="thickness">Line thickness</param>
/// <param name="color">Color used to draw the line</param>
/// <param name="outline">Outline width</param>
/// <param name="outlineColor">Color used to draw the outline</param>
/// <returns>New line shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Line(Vector2 p1, Vector2 p2, float thickness, Color color, float outline, Color outlineColor)
{
return new Shape(sfShape_CreateLine(p1.X, p1.Y, p2.X, p2.Y, thickness, color, outline, outlineColor));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create a shape made of a single rectangle
/// </summary>
/// <param name="rectangle">Rectangle to create</param>
/// <param name="color">Color used to fill the rectangle</param>
/// <returns>New rectangle shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Rectangle(FloatRect rectangle, Color color)
{
return Rectangle(rectangle, color, 0, Color.White);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create a shape made of a single rectangle
/// </summary>
/// <param name="rectangle">Rectangle to create</param>
/// <param name="color">Color used to fill the rectangle</param>
/// <param name="outline">Outline width</param>
/// <param name="outlineColor">Color used to draw the outline</param>
/// <returns>New rectangle shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Rectangle(FloatRect rectangle, Color color, float outline, Color outlineColor)
{
return new Shape(sfShape_CreateRectangle(rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height, color, outline, outlineColor));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create a shape made of a single circle
/// </summary>
/// <param name="center">Position of the center</param>
/// <param name="radius">Radius of the circle</param>
/// <param name="color">Color used to fill the circle</param>
/// <returns>New circle shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Circle(Vector2 center, float radius, Color color)
{
return Circle(center, radius, color, 0, Color.White);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create a shape made of a single circle
/// </summary>
/// <param name="center">Position of the center</param>
/// <param name="radius">Radius of the circle</param>
/// <param name="color">Color used to fill the circle</param>
/// <param name="outline">Outline width</param>
/// <param name="outlineColor">Color used to draw the outline</param>
/// <returns>New circle shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Circle(Vector2 center, float radius, Color color, float outline, Color outlineColor)
{
return new Shape(sfShape_CreateCircle(center.X, center.Y, radius, color, outline, outlineColor));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Shape]" +
" Position(" + Position + ")" +
" Rotation(" + Rotation + ")" +
" Scale(" + Scale + ")" +
" Origin(" + Origin + ")" +
" Color(" + Color + ")" +
" BlendMode(" + BlendMode + ")" +
" OutlineWidth(" + OutlineWidth + ")" +
" PointsCount(" + PointsCount + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Render the object into the given render window
/// </summary>
/// <param name="target">Target render window</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
internal override void Render(RenderWindow target, Shader shader)
{
if (shader == null)
sfRenderWindow_DrawShape(target.This, This);
else
sfRenderWindow_DrawShapeWithShader(target.This, This, shader.This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Render the object into the given render image
/// </summary>
/// <param name="target">Target render image</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
internal override void Render(RenderImage target, Shader shader)
{
if (shader == null)
sfRenderImage_DrawShape(target.This, This);
else
sfRenderImage_DrawShapeWithShader(target.This, This, shader.This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfShape_Destroy(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Internal constructor
/// </summary>
/// <param name="thisPtr">Pointer to the internal object in C library</param>
////////////////////////////////////////////////////////////
private Shape(IntPtr thisPtr) :
base(thisPtr)
{
}
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShape_Create();
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShape_Copy(IntPtr Shape);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_Destroy(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetPosition(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfShape_GetX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfShape_GetY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetRotation(IntPtr This, float Rotation);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfShape_GetRotation(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetScale(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfShape_GetScaleX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfShape_GetScaleY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetOrigin(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfShape_GetOriginX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfShape_GetOriginY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetColor(IntPtr This, Color Color);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Color sfShape_GetColor(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetBlendMode(IntPtr This, BlendMode Mode);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern BlendMode sfShape_GetBlendMode(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfShape_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfShape_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawShape(IntPtr This, IntPtr Shape);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawShapeWithShader(IntPtr This, IntPtr Shape, IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_DrawShape(IntPtr This, IntPtr Shape);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_DrawShapeWithShader(IntPtr This, IntPtr Shape, IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShape_CreateLine(float P1X, float P1Y, float P2X, float P2Y, float Thickness, Color Col, float Outline, Color OutlineCol);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShape_CreateRectangle(float P1X, float P1Y, float P2X, float P2Y, Color Col, float Outline, Color OutlineCol);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfShape_CreateCircle(float X, float Y, float Radius, Color Col, float Outline, Color OutlineCol);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_AddPoint(IntPtr This, float X, float Y, Color Col, Color OutlineCol);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_EnableFill(IntPtr This, bool Enable);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_EnableOutline(IntPtr This, bool Enable);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetOutlineWidth(IntPtr This, float Width);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfShape_GetOutlineWidth(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfShape_GetPointsCount(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetPointPosition(IntPtr This, uint Index, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_GetPointPosition(IntPtr This, uint Index, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetPointColor(IntPtr This, uint Index, Color Col);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Color sfShape_GetPointColor(IntPtr This, uint Index);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfShape_SetPointOutlineColor(IntPtr This, uint Index, Color Col);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Color sfShape_GetPointOutlineColor(IntPtr This, uint Index);
#endregion
}
}
}

396
bindings/dotnet/src/Graphics/Sprite.cs Normal file
View file

@ -0,0 +1,396 @@
using System;
using System.Security;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// This class defines a sprite : texture, transformations,
/// color, and draw on screen
/// </summary>
////////////////////////////////////////////////////////////
public class Sprite : Drawable
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor
/// </summary>
////////////////////////////////////////////////////////////
public Sprite() :
base(sfSprite_Create())
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the sprite from a source image
/// </summary>
/// <param name="image">Source image to assign to the sprite</param>
////////////////////////////////////////////////////////////
public Sprite(Image image) :
base(sfSprite_Create())
{
Image = image;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the sprite from another sprite
/// </summary>
/// <param name="copy">Sprite to copy</param>
////////////////////////////////////////////////////////////
public Sprite(Sprite copy) :
base(sfSprite_Copy(copy.This))
{
Image = copy.Image;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Position of the object on screen
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Position
{
get { return new Vector2(sfSprite_GetX(This), sfSprite_GetY(This)); }
set { sfSprite_SetPosition(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Rotation of the object, defined in degrees
/// </summary>
////////////////////////////////////////////////////////////
public override float Rotation
{
get { return sfSprite_GetRotation(This); }
set { sfSprite_SetRotation(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Vertical and horizontal scale of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Scale
{
get { return new Vector2(sfSprite_GetScaleX(This), sfSprite_GetScaleY(This)); }
set { sfSprite_SetScale(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Origin of the transformation of the object
/// (center of translation, rotation and scale)
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Origin
{
get { return new Vector2(sfSprite_GetOriginX(This), sfSprite_GetOriginY(This)); }
set { sfSprite_SetOrigin(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Global color of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Color Color
{
get { return sfSprite_GetColor(This); }
set { sfSprite_SetColor(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Blending mode of the object
/// </summary>
////////////////////////////////////////////////////////////
public override BlendMode BlendMode
{
get { return sfSprite_GetBlendMode(This); }
set { sfSprite_SetBlendMode(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Transform a point from global coordinates into local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
/// </summary>
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToLocal(Vector2 point)
{
Vector2 Transformed;
sfSprite_TransformToLocal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Transform a point from local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
/// </summary>
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToGlobal(Vector2 point)
{
Vector2 Transformed;
sfSprite_TransformToGlobal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Width of the sprite
/// </summary>
////////////////////////////////////////////////////////////
public float Width
{
get { return sfSprite_GetWidth(This); }
set { sfSprite_Resize(This, value, this.Height); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Height of the sprite
/// </summary>
////////////////////////////////////////////////////////////
public float Height
{
get { return sfSprite_GetHeight(This); }
set { sfSprite_Resize(This, this.Width, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Source images displayed by the sprite
/// </summary>
////////////////////////////////////////////////////////////
public Image Image
{
get { return myImage; }
set { myImage = value; sfSprite_SetImage(This, value != null ? value.This : IntPtr.Zero, false); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Sub-rectangle of the source image displayed by the sprite
/// </summary>
////////////////////////////////////////////////////////////
public IntRect SubRect
{
get { return sfSprite_GetSubRect(This); }
set { sfSprite_SetSubRect(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Flip the sprite horizontically
/// </summary>
/// <param name="flipped">True to flip, false to canel flip</param>
////////////////////////////////////////////////////////////
public void FlipX(bool flipped)
{
sfSprite_FlipX(This, flipped);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Flip the sprite vertically
/// </summary>
/// <param name="flipped">True to flip, false to canel flip</param>
////////////////////////////////////////////////////////////
public void FlipY(bool flipped)
{
sfSprite_FlipY(This, flipped);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the color of a given pixel in the sprite
/// (point is in local coordinates)
/// </summary>
/// <param name="x">X coordinate of the pixel to get</param>
/// <param name="y">Y coordinate of the pixel to get</param>
/// <returns>Color of pixel (x, y)</returns>
////////////////////////////////////////////////////////////
public Color GetPixel(uint x, uint y)
{
return sfSprite_GetPixel(This, x, y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Sprite]" +
" Position(" + Position + ")" +
" Rotation(" + Rotation + ")" +
" Scale(" + Scale + ")" +
" Origin(" + Origin + ")" +
" Color(" + Color + ")" +
" BlendMode(" + BlendMode + ")" +
" Width(" + Width + ")" +
" Height(" + Height + ")" +
" SubRect(" + SubRect + ")" +
" Image(" + Image + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Render the object into the given render window
/// </summary>
/// <param name="target">Target render window</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
internal override void Render(RenderWindow target, Shader shader)
{
if (shader == null)
sfRenderWindow_DrawSprite(target.This, This);
else
sfRenderWindow_DrawSpriteWithShader(target.This, This, shader.This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Render the object into the given render image
/// </summary>
/// <param name="target">Target render image</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
internal override void Render(RenderImage target, Shader shader)
{
if (shader == null)
sfRenderImage_DrawSprite(target.This, This);
else
sfRenderImage_DrawSpriteWithShader(target.This, This, shader.This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfSprite_Destroy(This);
}
private Image myImage = null;
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSprite_Create();
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfSprite_Copy(IntPtr Sprite);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_Destroy(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_SetPosition(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_SetRotation(IntPtr This, float Rotation);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetRotation(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_SetScale(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetScaleX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetScaleY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_SetOrigin(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetOriginX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetOriginY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_SetColor(IntPtr This, Color Color);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Color sfSprite_GetColor(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_SetBlendMode(IntPtr This, BlendMode Mode);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern BlendMode sfSprite_GetBlendMode(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfSprite_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfSprite_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawSprite(IntPtr This, IntPtr Sprite);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawSpriteWithShader(IntPtr This, IntPtr Sprite, IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_DrawSprite(IntPtr This, IntPtr Sprite);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_DrawSpriteWithShader(IntPtr This, IntPtr Sprite, IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_Resize(IntPtr This, float Width, float Height);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetWidth(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfSprite_GetHeight(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_SetImage(IntPtr This, IntPtr Image, bool AdjustToNewSize);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_SetSubRect(IntPtr This, IntRect Rect);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntRect sfSprite_GetSubRect(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_FlipX(IntPtr This, bool Flipped);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfSprite_FlipY(IntPtr This, bool Flipped);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Color sfSprite_GetPixel(IntPtr This, uint X, uint Y);
#endregion
}
}
}

439
bindings/dotnet/src/Graphics/Text.cs Normal file
View file

@ -0,0 +1,439 @@
using System;
using System.Security;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// This class defines a graphical 2D text, that can be drawn on screen
/// </summary>
////////////////////////////////////////////////////////////
public class Text : Drawable
{
////////////////////////////////////////////////////////////
/// <summary>
/// Enumerate the string drawing styles
/// </summary>
////////////////////////////////////////////////////////////
[Flags]
public enum Styles
{
/// <summary>Regular characters, no style</summary>
Regular = 0,
/// <summary> Characters are bold</summary>
Bold = 1 << 0,
/// <summary>Characters are in italic</summary>
Italic = 1 << 1,
/// <summary>Characters are underlined</summary>
Underlined = 1 << 2
}
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor
/// </summary>
////////////////////////////////////////////////////////////
public Text() :
this("")
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the text from a string
/// </summary>
/// <param name="str">String to display</param>
////////////////////////////////////////////////////////////
public Text(string str) :
this(str, Font.DefaultFont)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the text from a string and a font
/// </summary>
/// <param name="str">String to display</param>
/// <param name="font">Font to use</param>
////////////////////////////////////////////////////////////
public Text(string str, Font font) :
this(str, font, 30)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the text from a string, font and size
/// </summary>
/// <param name="str">String to display</param>
/// <param name="font">Font to use</param>
/// <param name="size">Base characters size</param>
////////////////////////////////////////////////////////////
public Text(string str, Font font, uint size) :
base(sfText_Create())
{
DisplayedString = str;
Font = font;
Size = size;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the text from another text
/// </summary>
/// <param name="copy">Text to copy</param>
////////////////////////////////////////////////////////////
public Text(Text copy) :
base(sfText_Copy(copy.This))
{
Font = copy.Font;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Position of the object on screen
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Position
{
get { return new Vector2(sfText_GetX(This), sfText_GetY(This)); }
set { sfText_SetPosition(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Rotation of the object, defined in degrees
/// </summary>
////////////////////////////////////////////////////////////
public override float Rotation
{
get { return sfText_GetRotation(This); }
set { sfText_SetRotation(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Vertical and horizontal scale of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Scale
{
get { return new Vector2(sfText_GetScaleX(This), sfText_GetScaleY(This)); }
set { sfText_SetScale(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Origin of the transformation of the object
/// (center of translation, rotation and scale)
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Origin
{
get { return new Vector2(sfText_GetOriginX(This), sfText_GetOriginY(This)); }
set { sfText_SetOrigin(This, value.X, value.Y); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Global color of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Color Color
{
get { return sfText_GetColor(This); }
set { sfText_SetColor(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Blending mode of the object
/// </summary>
////////////////////////////////////////////////////////////
public override BlendMode BlendMode
{
get { return sfText_GetBlendMode(This); }
set { sfText_SetBlendMode(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Transform a point from global coordinates into local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
/// </summary>
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToLocal(Vector2 point)
{
Vector2 Transformed;
sfText_TransformToLocal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Transform a point from local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
/// </summary>
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToGlobal(Vector2 point)
{
Vector2 Transformed;
sfText_TransformToGlobal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
}
////////////////////////////////////////////////////////////
/// <summary>
/// String which is displayed
/// </summary>
////////////////////////////////////////////////////////////
public string DisplayedString
{
// TODO : use unicode functions
// (convert from UTF-16 to UTF-32, and find how to marshal System.String as sfUint32*...)
get {return sfText_GetString(This);}
set {sfText_SetString(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Font used to display the text
/// </summary>
////////////////////////////////////////////////////////////
public Font Font
{
get {return myFont;}
set {myFont = value; sfText_SetFont(This, value != null ? value.This : IntPtr.Zero);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Base size of characters
/// </summary>
////////////////////////////////////////////////////////////
public uint Size
{
get {return sfText_GetCharacterSize(This);}
set {sfText_SetCharacterSize(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Style of the text (see Styles enum)
/// </summary>
////////////////////////////////////////////////////////////
public Styles Style
{
get {return sfText_GetStyle(This);}
set {sfText_SetStyle(This, value);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the text rectangle on screen
/// </summary>
/// <returns>Text rectangle in global coordinates (doesn't include rotation)</returns>
////////////////////////////////////////////////////////////
public FloatRect GetRect()
{
return sfText_GetRect(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Return the visual position of the Index-th character of the text,
/// in coordinates relative to the text
/// (note : translation, origin, rotation and scale are not applied)
/// </summary>
/// <param name="index">Index of the character</param>
/// <returns>Position of the Index-th character (end of text if Index is out of range)</returns>
////////////////////////////////////////////////////////////
public Vector2 GetCharacterPos(uint index)
{
Vector2 Pos;
sfText_GetCharacterPos(This, index, out Pos.X, out Pos.Y);
return Pos;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Text]" +
" Position(" + Position + ")" +
" Rotation(" + Rotation + ")" +
" Scale(" + Scale + ")" +
" Origin(" + Origin + ")" +
" Color(" + Color + ")" +
" BlendMode(" + BlendMode + ")" +
" String(" + DisplayedString + ")" +
" Font(" + Font + ")" +
" Size(" + Size + ")" +
" Style(" + Style + ")" +
" Rectangle(" + GetRect() + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Render the object into the given render window
/// </summary>
/// <param name="target">Target render window</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
internal override void Render(RenderWindow target, Shader shader)
{
if (shader == null)
sfRenderWindow_DrawText(target.This, This);
else
sfRenderWindow_DrawTextWithShader(target.This, This, shader.This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Render the object into the given render image
/// </summary>
/// <param name="target">Target render image</param>
/// <param name="shader">Shader to apply</param>
////////////////////////////////////////////////////////////
internal override void Render(RenderImage target, Shader shader)
{
if (shader == null)
sfRenderImage_DrawText(target.This, This);
else
sfRenderImage_DrawTextWithShader(target.This, This, shader.This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfText_Destroy(This);
}
private Font myFont = Font.DefaultFont;
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfText_Create();
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfText_Copy(IntPtr Text);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_Destroy(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetPosition(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfText_GetX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfText_GetY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetRotation(IntPtr This, float Rotation);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfText_GetRotation(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetScale(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfText_GetScaleX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfText_GetScaleY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetOrigin(IntPtr This, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfText_GetOriginX(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfText_GetOriginY(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetColor(IntPtr This, Color Color);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Color sfText_GetColor(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetBlendMode(IntPtr This, BlendMode Mode);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern BlendMode sfText_GetBlendMode(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfText_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfText_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawText(IntPtr This, IntPtr String);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawTextWithShader(IntPtr This, IntPtr String, IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_DrawText(IntPtr This, IntPtr String);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderImage_DrawTextWithShader(IntPtr This, IntPtr String, IntPtr Shader);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetString(IntPtr This, string Text);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetFont(IntPtr This, IntPtr Font);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetCharacterSize(IntPtr This, uint Size);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_SetStyle(IntPtr This, Styles Style);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity]
static extern string sfText_GetString(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfText_GetCharacterSize(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Styles sfText_GetStyle(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern FloatRect sfText_GetRect(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfText_GetCharacterPos(IntPtr This, uint Index, out float X, out float Y);
#endregion
}
}
}

127
bindings/dotnet/src/Graphics/Vector2.cs Normal file
View file

@ -0,0 +1,127 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Vector2 is an utility class for manipulating 2 dimensional
/// vectors with float components
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct Vector2
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the vector from its coordinates
/// </summary>
/// <param name="x">X coordinate</param>
/// <param name="y">Y coordinate</param>
////////////////////////////////////////////////////////////
public Vector2(float x, float y)
{
X = x;
Y = y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; returns the opposite of a vector
/// </summary>
/// <param name="v">Vector to negate</param>
/// <returns>-v</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator -(Vector2 v)
{
return new Vector2(-v.X, -v.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; subtracts two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 - v2</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator -(Vector2 v1, Vector2 v2)
{
return new Vector2(v1.X - v2.X, v1.Y - v2.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator + overload ; add two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 + v2</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator +(Vector2 v1, Vector2 v2)
{
return new Vector2(v1.X + v2.X, v1.Y + v2.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v * x</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator *(Vector2 v, float x)
{
return new Vector2(v.X * x, v.Y * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a scalar value by a vector
/// </summary>
/// <param name="x">Scalar value</param>
/// <param name="v">Vector</param>
/// <returns>x * v</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator *(float x, Vector2 v)
{
return new Vector2(v.X * x, v.Y * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator / overload ; divide a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v / x</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator /(Vector2 v, float x)
{
return new Vector2(v.X / x, v.Y / x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Vector2]" +
" X(" + X + ")" +
" Y(" + Y + ")";
}
/// <summary>X (horizontal) component of the vector</summary>
public float X;
/// <summary>Y (vertical) component of the vector</summary>
public float Y;
}
}
}

247
bindings/dotnet/src/Graphics/View.cs Normal file
View file

@ -0,0 +1,247 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// This class defines a view (position, size, etc.) ;
/// you can consider it as a 2D camera
/// </summary>
////////////////////////////////////////////////////////////
public class View : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Create a default view (1000x1000)
/// </summary>
////////////////////////////////////////////////////////////
public View() :
base(sfView_Create())
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the view from a rectangle
/// </summary>
/// <param name="viewRect">Rectangle defining the position and size of the view</param>
////////////////////////////////////////////////////////////
public View(FloatRect viewRect) :
base(sfView_CreateFromRect(viewRect))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the view from its center and size
/// </summary>
/// <param name="center">Center of the view</param>
/// <param name="size">Size of the view</param>
////////////////////////////////////////////////////////////
public View(Vector2 center, Vector2 size) :
base(sfView_Create())
{
this.Center = center;
this.Size = size;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the view from another view
/// </summary>
/// <param name="copy">View to copy</param>
////////////////////////////////////////////////////////////
public View(View copy) :
base(sfView_Copy(copy.This))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Center of the view
/// </summary>
////////////////////////////////////////////////////////////
public Vector2 Center
{
get {return new Vector2(sfView_GetCenterX(This), sfView_GetCenterY(This));}
set {sfView_SetCenter(This, value.X, value.Y);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Half-size of the view
/// </summary>
////////////////////////////////////////////////////////////
public Vector2 Size
{
get {return new Vector2(sfView_GetWidth(This), sfView_GetHeight(This));}
set {sfView_SetSize(This, value.X, value.Y);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Rotation of the view, in degrees
/// </summary>
////////////////////////////////////////////////////////////
public float Rotation
{
get { return sfView_GetRotation(This); }
set { sfView_SetRotation(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Target viewport of the view, defined as a factor of the
/// size of the target to which the view is applied
/// </summary>
////////////////////////////////////////////////////////////
public FloatRect Viewport
{
get { return sfView_GetViewport(This); }
set { sfView_SetViewport(This, value); }
}
////////////////////////////////////////////////////////////
/// <summary>
/// Rebuild the view from a rectangle
/// </summary>
/// <param name="rectangle">Rectangle defining the position and size of the view</param>
////////////////////////////////////////////////////////////
public void Reset(FloatRect rectangle)
{
sfView_Reset(This, rectangle);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Move the view
/// </summary>
/// <param name="offset">Offset to move the view</param>
////////////////////////////////////////////////////////////
public void Move(Vector2 offset)
{
sfView_Move(This, offset.X, offset.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Rotate the view
/// </summary>
/// <param name="angle">Angle of rotation, in degrees</param>
////////////////////////////////////////////////////////////
public void Rotate(float angle)
{
sfView_Rotate(This, angle);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Resize the view rectangle to simulate a zoom / unzoom effect
/// </summary>
/// <param name="factor">Zoom factor to apply, relative to the current zoom</param>
////////////////////////////////////////////////////////////
public void Zoom(float factor)
{
sfView_Zoom(This, factor);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[View]" +
" Center(" + Center + ")" +
" Size(" + Size + ")" +
" Rotation(" + Rotation + ")" +
" Viewport(" + Viewport + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Internal constructor for other classes which need to manipulate raw views
/// </summary>
/// <param name="thisPtr">Direct pointer to the view object in the C library</param>
////////////////////////////////////////////////////////////
internal View(IntPtr thisPtr) :
base(thisPtr)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfView_Destroy(This);
}
#region Imports
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfView_Create();
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfView_CreateFromRect(FloatRect Rect);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfView_Copy(IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_Destroy(IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_SetCenter(IntPtr View, float X, float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_SetSize(IntPtr View, float Width, float Height);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_SetRotation(IntPtr View, float Angle);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_SetViewport(IntPtr View, FloatRect Viewport);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_Reset(IntPtr View, FloatRect Rectangle);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfView_GetCenterX(IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfView_GetCenterY(IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfView_GetWidth(IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfView_GetHeight(IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfView_GetRotation(IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern FloatRect sfView_GetViewport(IntPtr View);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_Move(IntPtr View, float OffsetX, float OffsetY);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_Rotate(IntPtr View, float Angle);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfView_Zoom(IntPtr View, float Factor);
#endregion
}
}
}

79
bindings/dotnet/src/Graphics/sfml-graphics.csproj Normal file
View file

@ -0,0 +1,79 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{46786269-57B9-48E7-AA4F-8F4D84609FE6}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>SFML.Graphics</RootNamespace>
<AssemblyName>sfmlnet-graphics-2</AssemblyName>
<StartupObject>
</StartupObject>
<FileUpgradeFlags>
</FileUpgradeFlags>
<OldToolsVersion>2.0</OldToolsVersion>
<UpgradeBackupLocation>
</UpgradeBackupLocation>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>..\..\lib\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<DocumentationFile>..\..\doc\build\graphics-doc.xml</DocumentationFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>..\..\lib\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<DocumentationFile>..\..\doc\build\graphics-doc.xml</DocumentationFile>
</PropertyGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<ItemGroup>
<Compile Include="Color.cs" />
<Compile Include="Context.cs" />
<Compile Include="Drawable.cs" />
<Compile Include="Font.cs" />
<Compile Include="Image.cs" />
<Compile Include="Rect.cs" />
<Compile Include="RenderImage.cs" />
<Compile Include="RenderTarget.cs" />
<Compile Include="RenderWindow.cs" />
<Compile Include="Shader.cs" />
<Compile Include="Shape.cs" />
<Compile Include="Sprite.cs" />
<Compile Include="Text.cs" />
<Compile Include="Vector2.cs" />
<Compile Include="View.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Window\sfml-window.csproj">
<Project>{D17DE83D-A592-461F-8AF2-53F9E22E1D0F}</Project>
<Name>sfml-window</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Reference Include="System" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>

92
bindings/dotnet/src/Window/ContextSettings.cs Normal file
View file

@ -0,0 +1,92 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Structure defining the creation settings of OpenGL contexts
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct ContextSettings
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the settings from depth / stencil bits
/// </summary>
/// <param name="depthBits">Depth buffer bits</param>
/// <param name="stencilBits">Stencil buffer bits</param>
////////////////////////////////////////////////////////////
public ContextSettings(uint depthBits, uint stencilBits) :
this(depthBits, stencilBits, 0)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the settings from depth / stencil bits and antialiasing level
/// </summary>
/// <param name="depthBits">Depth buffer bits</param>
/// <param name="stencilBits">Stencil buffer bits</param>
/// <param name="antialiasingLevel">Antialiasing level</param>
////////////////////////////////////////////////////////////
public ContextSettings(uint depthBits, uint stencilBits, uint antialiasingLevel) :
this(depthBits, stencilBits, antialiasingLevel, 2, 0)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the settings from depth / stencil bits and antialiasing level
/// </summary>
/// <param name="depthBits">Depth buffer bits</param>
/// <param name="stencilBits">Stencil buffer bits</param>
/// <param name="antialiasingLevel">Antialiasing level</param>
/// <param name="majorVersion">Major number of the context version</param>
/// <param name="minorVersion">Minor number of the context version</param>
////////////////////////////////////////////////////////////
public ContextSettings(uint depthBits, uint stencilBits, uint antialiasingLevel, uint majorVersion, uint minorVersion)
{
DepthBits = depthBits;
StencilBits = stencilBits;
AntialiasingLevel = antialiasingLevel;
MajorVersion = majorVersion;
MinorVersion = minorVersion;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[ContextSettings]" +
" DepthBits(" + DepthBits + ")" +
" StencilBits(" + StencilBits + ")" +
" AntialiasingLevel(" + AntialiasingLevel + ")" +
" MajorVersion(" + MajorVersion + ")" +
" MinorVersion(" + MinorVersion + ")";
}
/// <summary>Depth buffer bits (0 is disabled)</summary>
public uint DepthBits;
/// <summary>Stencil buffer bits (0 is disabled)</summary>
public uint StencilBits;
/// <summary>Antialiasing level (0 is disabled)</summary>
public uint AntialiasingLevel;
/// <summary>Major number of the context version</summary>
public uint MajorVersion;
/// <summary>Minor number of the context version</summary>
public uint MinorVersion;
}
}
}

403
bindings/dotnet/src/Window/Event.cs Normal file
View file

@ -0,0 +1,403 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Definition of key codes for keyboard events
/// </summary>
////////////////////////////////////////////////////////////
public enum KeyCode
{
A = 'a',
B = 'b',
C = 'c',
D = 'd',
E = 'e',
F = 'f',
G = 'g',
H = 'h',
I = 'i',
J = 'j',
K = 'k',
L = 'l',
M = 'm',
N = 'n',
O = 'o',
P = 'p',
Q = 'q',
R = 'r',
S = 's',
T = 't',
U = 'u',
V = 'v',
W = 'w',
X = 'x',
Y = 'y',
Z = 'z',
Num0 = '0',
Num1 = '1',
Num2 = '2',
Num3 = '3',
Num4 = '4',
Num5 = '5',
Num6 = '6',
Num7 = '7',
Num8 = '8',
Num9 = '9',
Escape = 256,
LControl,
LShift,
LAlt,
LSystem, // OS specific key (left side) : windows (Win and Linux), apple (MacOS), ...
RControl,
RShift,
RAlt,
RSystem, // OS specific key (right side) : windows (Win and Linux), apple (MacOS), ...
Menu,
LBracket, // [
RBracket, // ]
SemiColon, // ;
Comma, // ,
Period, // .
Quote, // '
Slash, // /
BackSlash,
Tilde, // ~
Equal, // =
Dash, // -
Space,
Return,
Back,
Tab,
PageUp,
PageDown,
End,
Home,
Insert,
Delete,
Add, // +
Subtract, // -
Multiply, // *
Divide, // /
Left, // Left arrow
Right, // Right arrow
Up, // Up arrow
Down, // Down arrow
Numpad0,
Numpad1,
Numpad2,
Numpad3,
Numpad4,
Numpad5,
Numpad6,
Numpad7,
Numpad8,
Numpad9,
F1,
F2,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
F10,
F11,
F12,
F13,
F14,
F15,
Pause
}
////////////////////////////////////////////////////////////
/// <summary>
/// Definition of button codes for mouse events
/// </summary>
////////////////////////////////////////////////////////////
public enum MouseButton
{
/// <summary>Left mouse button</summary>
Left,
/// <summary>Right mouse button</summary>
Right,
/// <summary>Center (wheel) mouse button</summary>
Middle,
/// <summary>First extra button</summary>
XButton1,
/// <summary>Second extra button</summary>
XButton2
}
////////////////////////////////////////////////////////////
/// <summary>
/// Definition of joystick axis for joystick events
/// </summary>
////////////////////////////////////////////////////////////
public enum JoyAxis
{
/// <summary>X axis</summary>
AxisX,
/// <summary>Y axis</summary>
AxisY,
/// <summary>Z axis</summary>
AxisZ,
/// <summary>R axis</summary>
AxisR,
/// <summary>U axis</summary>
AxisU,
/// <summary>V axis</summary>
AxisV,
/// <summary>Point of view</summary>
AxisPOV
}
////////////////////////////////////////////////////////////
/// <summary>
/// Enumeration of the different types of events
/// </summary>
////////////////////////////////////////////////////////////
public enum EventType
{
/// <summary>Event triggered when a window is manually closed</summary>
Closed,
/// <summary>Event triggered when a window is resized</summary>
Resized,
/// <summary>Event triggered when a window loses the focus</summary>
LostFocus,
/// <summary>Event triggered when a window gains the focus</summary>
GainedFocus,
/// <summary>Event triggered when a valid character is entered</summary>
TextEntered,
/// <summary>Event triggered when a keyboard key is pressed</summary>
KeyPressed,
/// <summary>Event triggered when a keyboard key is released</summary>
KeyReleased,
/// <summary>Event triggered when the mouse wheel is scrolled</summary>
MouseWheelMoved,
/// <summary>Event triggered when a mouse button is pressed</summary>
MouseButtonPressed,
/// <summary>Event triggered when a mouse button is released</summary>
MouseButtonReleased,
/// <summary>Event triggered when the mouse moves within the area of a window</summary>
MouseMoved,
/// <summary>Event triggered when the mouse enters the area of a window</summary>
MouseEntered,
/// <summary>Event triggered when the mouse leaves the area of a window</summary>
MouseLeft,
/// <summary>Event triggered when a joystick button is pressed</summary>
JoyButtonPressed,
/// <summary>Event triggered when a joystick button is released</summary>
JoyButtonReleased,
/// <summary>Event triggered when a joystick axis moves</summary>
JoyMoved
}
////////////////////////////////////////////////////////////
/// <summary>
/// Keyboard event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct KeyEvent
{
/// <summary>Code of the key (see KeyCode enum)</summary>
public KeyCode Code;
/// <summary>Is the Alt modifier pressed?</summary>
public int Alt;
/// <summary>Is the Control modifier pressed?</summary>
public int Control;
/// <summary>Is the Shift modifier pressed?</summary>
public int Shift;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Text event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct TextEvent
{
/// <summary>UTF-32 value of the character</summary>
public uint Unicode;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Mouse move event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct MouseMoveEvent
{
/// <summary>X coordinate of the mouse cursor</summary>
public int X;
/// <summary>Y coordinate of the mouse cursor</summary>
public int Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Mouse buttons event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct MouseButtonEvent
{
/// <summary>Code of the button (see MouseButton enum)</summary>
public MouseButton Button;
/// <summary>X coordinate of the mouse cursor</summary>
public int X;
/// <summary>Y coordinate of the mouse cursor</summary>
public int Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Mouse wheel event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct MouseWheelEvent
{
/// <summary>Scroll amount</summary>
public int Delta;
/// <summary>X coordinate of the mouse cursor</summary>
public int X;
/// <summary>Y coordinate of the mouse cursor</summary>
public int Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Joystick axis move event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct JoyMoveEvent
{
/// <summary>Index of the joystick which triggered the event</summary>
public uint JoystickId;
/// <summary>Joystick axis (see JoyAxis enum)</summary>
public JoyAxis Axis;
/// <summary>Current position of the axis</summary>
public float Position;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Joystick buttons event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct JoyButtonEvent
{
/// <summary>Index of the joystick which triggered the event</summary>
public uint JoystickId;
/// <summary>Index of the button</summary>
public uint Button;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Size event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct SizeEvent
{
/// <summary>New width of the window</summary>
public uint Width;
/// <summary>New height of the window</summary>
public uint Height;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Event defines a system event and its parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Explicit, Size = 20)]
public struct Event
{
/// <summary>Type of event (see EventType enum)</summary>
[FieldOffset(0)]
public EventType Type;
/// <summary>Arguments for key events (KeyPressed, KeyReleased)</summary>
[FieldOffset(4)]
public KeyEvent Key;
/// <summary>Arguments for text events (TextEntered)</summary>
[FieldOffset(4)]
public TextEvent Text;
/// <summary>Arguments for mouse move events (MouseMoved)</summary>
[FieldOffset(4)]
public MouseMoveEvent MouseMove;
/// <summary>Arguments for mouse button events (MouseButtonPressed, MouseButtonReleased)</summary>
[FieldOffset(4)]
public MouseButtonEvent MouseButton;
/// <summary>Arguments for mouse wheel events (MouseWheelMoved)</summary>
[FieldOffset(4)]
public MouseWheelEvent MouseWheel;
/// <summary>Arguments for joystick axis events (JoyMoved)</summary>
[FieldOffset(4)]
public JoyMoveEvent JoyMove;
/// <summary>Arguments for joystick button events (JoyButtonPressed, JoyButtonReleased)</summary>
[FieldOffset(4)]
public JoyButtonEvent JoyButton;
/// <summary>Arguments for size events (Resized)</summary>
[FieldOffset(4)]
public SizeEvent Size;
}
}
}

339
bindings/dotnet/src/Window/EventArgs.cs Normal file
View file

@ -0,0 +1,339 @@
using System;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Keyboard event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class KeyEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the key arguments from a key event
/// </summary>
/// <param name="e">Key event</param>
////////////////////////////////////////////////////////////
public KeyEventArgs(KeyEvent e)
{
Code = e.Code;
Alt = e.Alt != 0;
Control = e.Control != 0;
Shift = e.Shift != 0;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[KeyEventArgs]" +
" Code(" + Code + ")" +
" Alt(" + Alt + ")" +
" Control(" + Control + ")" +
" Shift(" + Shift + ")";
}
/// <summary>Code of the key (see KeyCode enum)</summary>
public KeyCode Code;
/// <summary>Is the Alt modifier pressed?</summary>
public bool Alt;
/// <summary>Is the Control modifier pressed?</summary>
public bool Control;
/// <summary>Is the Shift modifier pressed?</summary>
public bool Shift;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Text event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class TextEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the text arguments from a text event
/// </summary>
/// <param name="e">Text event</param>
////////////////////////////////////////////////////////////
public TextEventArgs(TextEvent e)
{
Unicode = Char.ConvertFromUtf32((int)e.Unicode);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[TextEventArgs]" +
" Unicode(" + Unicode + ")";
}
/// <summary>UTF-16 value of the character</summary>
public string Unicode;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Mouse move event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class MouseMoveEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the mouse move arguments from a mouse move event
/// </summary>
/// <param name="e">Mouse move event</param>
////////////////////////////////////////////////////////////
public MouseMoveEventArgs(MouseMoveEvent e)
{
X = e.X;
Y = e.Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[MouseMoveEventArgs]" +
" X(" + X + ")" +
" Y(" + Y + ")";
}
/// <summary>X coordinate of the mouse cursor</summary>
public int X;
/// <summary>Y coordinate of the mouse cursor</summary>
public int Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Mouse buttons event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class MouseButtonEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the mouse button arguments from a mouse button event
/// </summary>
/// <param name="e">Mouse button event</param>
////////////////////////////////////////////////////////////
public MouseButtonEventArgs(MouseButtonEvent e)
{
Button = e.Button;
X = e.X;
Y = e.Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[MouseButtonEventArgs]" +
" Button(" + Button + ")" +
" X(" + X + ")" +
" Y(" + Y + ")";
}
/// <summary>Code of the button (see MouseButton enum)</summary>
public MouseButton Button;
/// <summary>X coordinate of the mouse cursor</summary>
public int X;
/// <summary>Y coordinate of the mouse cursor</summary>
public int Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Mouse wheel event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class MouseWheelEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the mouse wheel arguments from a mouse wheel event
/// </summary>
/// <param name="e">Mouse wheel event</param>
////////////////////////////////////////////////////////////
public MouseWheelEventArgs(MouseWheelEvent e)
{
Delta = e.Delta;
X = e.X;
Y = e.Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[MouseWheelEventArgs]" +
" Delta(" + Delta + ")" +
" X(" + X + ")" +
" Y(" + Y + ")";
}
/// <summary>Scroll amount</summary>
public int Delta;
/// <summary>X coordinate of the mouse cursor</summary>
public int X;
/// <summary>Y coordinate of the mouse cursor</summary>
public int Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Joystick axis move event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class JoyMoveEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the joystick move arguments from a joystick move event
/// </summary>
/// <param name="e">Joystick move event</param>
////////////////////////////////////////////////////////////
public JoyMoveEventArgs(JoyMoveEvent e)
{
JoystickId = e.JoystickId;
Axis = e.Axis;
Position = e.Position;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[JoyMoveEventArgs]" +
" JoystickId(" + JoystickId + ")" +
" Axis(" + Axis + ")" +
" Position(" + Position + ")";
}
/// <summary>Index of the joystick which triggered the event</summary>
public uint JoystickId;
/// <summary>Joystick axis (see JoyAxis enum)</summary>
public JoyAxis Axis;
/// <summary>Current position of the axis</summary>
public float Position;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Joystick buttons event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class JoyButtonEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the joystick button arguments from a joystick button event
/// </summary>
/// <param name="e">Joystick button event</param>
////////////////////////////////////////////////////////////
public JoyButtonEventArgs(JoyButtonEvent e)
{
JoystickId = e.JoystickId;
Button = e.Button;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[JoyButtonEventArgs]" +
" JoystickId(" + JoystickId + ")" +
" Button(" + Button + ")";
}
/// <summary>Index of the joystick which triggered the event</summary>
public uint JoystickId;
/// <summary>Index of the button</summary>
public uint Button;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Size event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class SizeEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the size arguments from a size event
/// </summary>
/// <param name="e">Size event</param>
////////////////////////////////////////////////////////////
public SizeEventArgs(SizeEvent e)
{
Width = e.Width;
Height = e.Height;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[SizeEventArgs]" +
" Width(" + Width + ")" +
" Height(" + Height + ")";
}
/// <summary>New width of the window</summary>
public uint Width;
/// <summary>New height of the window</summary>
public uint Height;
}
}
}

144
bindings/dotnet/src/Window/Input.cs Normal file
View file

@ -0,0 +1,144 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Input handles real-time input from keyboard and mouse.
/// Use it instead of events to handle continuous moves and more
/// game-friendly inputs
/// </summary>
////////////////////////////////////////////////////////////
public class Input : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Get the state of a key
/// </summary>
/// <param name="key">Key to check</param>
/// <returns>True if key is down, false if key is up</returns>
////////////////////////////////////////////////////////////
public bool IsKeyDown(KeyCode key)
{
return sfInput_IsKeyDown(This, key);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the state of a mouse button
/// </summary>
/// <param name="button">Button to check</param>
/// <returns>True if button is down, false if button is up</returns>
////////////////////////////////////////////////////////////
public bool IsMouseButtonDown(MouseButton button)
{
return sfInput_IsMouseButtonDown(This, button);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the state of a joystick button
/// </summary>
/// <param name="joystickId">Identifier of the joystick to check (0 or 1)</param>
/// <param name="button">Button to check</param>
/// <returns>True if button is down, false if button is up</returns>
////////////////////////////////////////////////////////////
public bool IsJoystickButtonDown(uint joystickId, uint button)
{
return sfInput_IsJoystickButtonDown(This, joystickId, button);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the mouse X position
/// </summary>
/// <returns>Current mouse left position, relative to owner window</returns>
////////////////////////////////////////////////////////////
public int GetMouseX()
{
return sfInput_GetMouseX(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the mouse Y position
/// </summary>
/// <returns>Current mouse top position, relative to owner window</returns>
////////////////////////////////////////////////////////////
public int GetMouseY()
{
return sfInput_GetMouseY(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get a joystick axis position
/// </summary>
/// <param name="joystickId">Identifier of the joystick to check (0 or 1)</param>
/// <param name="axis">Axis to get</param>
/// <returns>Current axis position, in the range [-100, 100] (except for POV, which is [0, 360])</returns>
////////////////////////////////////////////////////////////
public float GetJoystickAxis(uint joystickId, JoyAxis axis)
{
return sfInput_GetJoystickAxis(This, joystickId, axis);
}
////////////////////////////////////////////////////////////
/// <summary>
/// For internal use only, construct the instance from a direct pointer to the internal object
/// </summary>
/// <param name="thisPtr">Internal pointer to the input object</param>
////////////////////////////////////////////////////////////
public Input(IntPtr thisPtr) :
base(thisPtr)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Input]";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
// Nothing to do here, Input instances are owned by the C library
}
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfInput_IsKeyDown(IntPtr This, KeyCode Key);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfInput_IsMouseButtonDown(IntPtr This, MouseButton Button);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfInput_IsJoystickButtonDown(IntPtr This, uint JoyId, uint Button);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern int sfInput_GetMouseX(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern int sfInput_GetMouseY(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfInput_GetJoystickAxis(IntPtr This, uint JoyId, JoyAxis Axis);
#endregion
}
}
}

84
bindings/dotnet/src/Window/LoadingFailedException.cs Normal file
View file

@ -0,0 +1,84 @@
using System;
using System.Runtime.Serialization;
namespace SFML
{
////////////////////////////////////////////////////////////
/// <summary>
/// Exception thrown by SFML whenever loading a resource fails
/// </summary>
////////////////////////////////////////////////////////////
[Serializable]
public class LoadingFailedException : Exception
{
////////////////////////////////////////////////////////////
/// <summary>
/// Default constructor (unknown error)
/// </summary>
////////////////////////////////////////////////////////////
public LoadingFailedException() :
base("Failed to load a resource")
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Failure to load a resource from memory
/// </summary>
/// <param name="resourceName">Name of the resource</param>
////////////////////////////////////////////////////////////
public LoadingFailedException(string resourceName) :
base("Failed to load " + resourceName + " from memory")
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Failure to load a resource from memory
/// </summary>
/// <param name="resourceName">Name of the resource</param>
/// <param name="innerException">Exception which is the cause ofthe current exception</param>
////////////////////////////////////////////////////////////
public LoadingFailedException(string resourceName, Exception innerException) :
base("Failed to load " + resourceName + " from memory", innerException)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Failure to load a resource from a file
/// </summary>
/// <param name="resourceName">Name of the resource</param>
/// <param name="filename">Path of the file</param>
////////////////////////////////////////////////////////////
public LoadingFailedException(string resourceName, string filename) :
base("Failed to load " + resourceName + " from file " + filename)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Failure to load a resource from a file
/// </summary>
/// <param name="resourceName">Name of the resource</param>
/// <param name="filename">Path of the file</param>
/// <param name="innerException">Exception which is the cause ofthe current exception</param>
////////////////////////////////////////////////////////////
public LoadingFailedException(string resourceName, string filename, Exception innerException) :
base("Failed to load " + resourceName + " from file " + filename, innerException)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Initialize an instance of the exception with serialized data
/// </summary>
/// <param name="info">Serialized data</param>
/// <param name="context">Contextual informations</param>
////////////////////////////////////////////////////////////
public LoadingFailedException(SerializationInfo info, StreamingContext context) :
base(info, context)
{
}
}
}

93
bindings/dotnet/src/Window/ObjectBase.cs Normal file
View file

@ -0,0 +1,93 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
////////////////////////////////////////////////////////////
/// <summary>
/// The ObjectBase class is an abstract base for every
/// SFML object. It's meant for internal use only
/// </summary>
////////////////////////////////////////////////////////////
public abstract class ObjectBase : IDisposable
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the object from a pointer to the C library object
/// </summary>
/// <param name="thisPtr">Internal pointer to the object in the C libraries</param>
////////////////////////////////////////////////////////////
public ObjectBase(IntPtr thisPtr)
{
myThis = thisPtr;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Dispose the object
/// </summary>
////////////////////////////////////////////////////////////
~ObjectBase()
{
Dispose(false);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Access to the internal pointer of the object.
/// For internal use only
/// </summary>
////////////////////////////////////////////////////////////
public IntPtr This
{
get {return myThis;}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Explicitely dispose the object
/// </summary>
////////////////////////////////////////////////////////////
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Destroy the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
private void Dispose(bool disposing)
{
if (myThis != IntPtr.Zero)
{
Destroy(disposing);
myThis = IntPtr.Zero;
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Destroy the object (implementation is left to each derived class)
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected abstract void Destroy(bool disposing);
////////////////////////////////////////////////////////////
/// <summary>
/// Set the pointer to the internal object. For internal use only
/// </summary>
/// <param name="thisPtr">Pointer to the internal object in C library</param>
////////////////////////////////////////////////////////////
protected void SetThis(IntPtr thisPtr)
{
myThis = thisPtr;
}
private IntPtr myThis = IntPtr.Zero;
}
}

124
bindings/dotnet/src/Window/VideoMode.cs Normal file
View file

@ -0,0 +1,124 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// VideoMode defines a video mode (width, height, bpp, frequency)
/// and provides static functions for getting modes supported
/// by the display device
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct VideoMode
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the video mode with its width and height
/// </summary>
/// <param name="width">Video mode width</param>
/// <param name="height">Video mode height</param>
////////////////////////////////////////////////////////////
public VideoMode(uint width, uint height) :
this(width, height, 32)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the video mode with its width, height and depth
/// </summary>
/// <param name="width">Video mode width</param>
/// <param name="height">Video mode height</param>
/// <param name="bpp">Video mode depth (bits per pixel)</param>
////////////////////////////////////////////////////////////
public VideoMode(uint width, uint height, uint bpp)
{
Width = width;
Height = height;
BitsPerPixel = bpp;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Tell whether or not the video mode is supported
/// </summary>
/// <returns>True if the video mode is valid, false otherwise</returns>
////////////////////////////////////////////////////////////
public bool IsValid()
{
return sfVideoMode_IsValid(this);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the list of all the supported fullscreen video modes
/// </summary>
////////////////////////////////////////////////////////////
public static VideoMode[] FullscreenModes
{
get
{
unsafe
{
uint Count;
VideoMode* ModesPtr = sfVideoMode_GetFullscreenModes(out Count);
VideoMode[] Modes = new VideoMode[Count];
for (uint i = 0; i < Count; ++i)
Modes[i] = ModesPtr[i];
return Modes;
}
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the current desktop video mode
/// </summary>
////////////////////////////////////////////////////////////
public static VideoMode DesktopMode
{
get {return sfVideoMode_GetDesktopMode();}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[VideoMode]" +
" Width(" + Width + ")" +
" Height(" + Height + ")" +
" BitsPerPixel(" + BitsPerPixel + ")";
}
/// <summary>Video mode width, in pixels</summary>
public uint Width;
/// <summary>Video mode height, in pixels</summary>
public uint Height;
/// <summary>Video mode depth, in bits per pixel</summary>
public uint BitsPerPixel;
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern VideoMode sfVideoMode_GetDesktopMode();
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern VideoMode* sfVideoMode_GetFullscreenModes(out uint Count);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfVideoMode_IsValid(VideoMode Mode);
#endregion
}
}
}

661
bindings/dotnet/src/Window/Window.cs Normal file
View file

@ -0,0 +1,661 @@
using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Security;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Enumeration of window creation styles
/// </summary>
////////////////////////////////////////////////////////////
[Flags]
public enum Styles
{
/// <summary>No border / title bar (this flag and all others are mutually exclusive)</summary>
None = 0,
/// <summary>Title bar + fixed border</summary>
Titlebar = 1 << 0,
/// <summary>Titlebar + resizable border + maximize button</summary>
Resize = 1 << 1,
/// <summary>Titlebar + close button</summary>
Close = 1 << 2,
/// <summary>Fullscreen mode (this flag and all others are mutually exclusive))</summary>
Fullscreen = 1 << 3,
/// <summary>Default window style (titlebar + resize + close)</summary>
Default = Titlebar | Resize | Close
}
////////////////////////////////////////////////////////////
/// <summary>
/// Window is a rendering window ; it can create a new window
/// or connect to an existing one
/// </summary>
////////////////////////////////////////////////////////////
public class Window : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window with default style and creation settings
/// </summary>
/// <param name="mode">Video mode to use</param>
/// <param name="title">Title of the window</param>
////////////////////////////////////////////////////////////
public Window(VideoMode mode, string title) :
this(mode, title, Styles.Default, new ContextSettings(24, 8))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window with default creation settings
/// </summary>
/// <param name="mode">Video mode to use</param>
/// <param name="title">Title of the window</param>
/// <param name="style">Window style (Resize | Close by default)</param>
////////////////////////////////////////////////////////////
public Window(VideoMode mode, string title, Styles style) :
this(mode, title, style, new ContextSettings(24, 8))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window
/// </summary>
/// <param name="mode">Video mode to use</param>
/// <param name="title">Title of the window</param>
/// <param name="style">Window style (Resize | Close by default)</param>
/// <param name="settings">Creation parameters</param>
////////////////////////////////////////////////////////////
public Window(VideoMode mode, string title, Styles style, ContextSettings settings) :
base(sfWindow_Create(mode, title, style, ref settings))
{
myInput = new Input(sfWindow_GetInput(This));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window from an existing control with default creation settings
/// </summary>
/// <param name="handle">Platform-specific handle of the control</param>
////////////////////////////////////////////////////////////
public Window(IntPtr handle) :
this(handle, new ContextSettings(24, 8))
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Create the window from an existing control
/// </summary>
/// <param name="Handle">Platform-specific handle of the control</param>
/// <param name="settings">Creation parameters</param>
////////////////////////////////////////////////////////////
public Window(IntPtr Handle, ContextSettings settings) :
base(sfWindow_CreateFromHandle(Handle, ref settings))
{
myInput = new Input(sfWindow_GetInput(This));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Input manager of the window
/// </summary>
////////////////////////////////////////////////////////////
public Input Input
{
get {return myInput;}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Tell whether or not the window is opened (ie. has been created).
/// Note that a hidden window (Show(false))
/// will still return true
/// </summary>
/// <returns>True if the window is opened</returns>
////////////////////////////////////////////////////////////
public virtual bool IsOpened()
{
return sfWindow_IsOpened(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Close (destroy) the window.
/// The Window instance remains valid and you can call
/// Create to recreate the window
/// </summary>
////////////////////////////////////////////////////////////
public virtual void Close()
{
sfWindow_Close(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Display the window on screen
/// </summary>
////////////////////////////////////////////////////////////
public virtual void Display()
{
sfWindow_Display(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Width of the rendering region of the window
/// </summary>
////////////////////////////////////////////////////////////
public virtual uint Width
{
get {return sfWindow_GetWidth(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Height of the rendering region of the window
/// </summary>
////////////////////////////////////////////////////////////
public virtual uint Height
{
get {return sfWindow_GetHeight(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Creation settings of the window
/// </summary>
////////////////////////////////////////////////////////////
public virtual ContextSettings Settings
{
get {return sfWindow_GetSettings(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Enable / disable vertical synchronization
/// </summary>
/// <param name="enable">True to enable v-sync, false to deactivate</param>
////////////////////////////////////////////////////////////
public virtual void UseVerticalSync(bool enable)
{
sfWindow_UseVerticalSync(This, enable);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Show or hide the mouse cursor
/// </summary>
/// <param name="show">True to show, false to hide</param>
////////////////////////////////////////////////////////////
public virtual void ShowMouseCursor(bool show)
{
sfWindow_ShowMouseCursor(This, show);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the position of the mouse cursor
/// </summary>
/// <param name="x">Left coordinate of the cursor, relative to the window</param>
/// <param name="y">Top coordinate of the cursor, relative to the window</param>
////////////////////////////////////////////////////////////
public virtual void SetCursorPosition(uint x, uint y)
{
sfWindow_SetCursorPosition(This, x, y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the position of the window on screen.
/// Only works for top-level windows
/// </summary>
/// <param name="x">Left position</param>
/// <param name="y">Top position</param>
////////////////////////////////////////////////////////////
public virtual void SetPosition(int x, int y)
{
sfWindow_SetPosition(This, x, y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the size of the rendering region of the window
/// </summary>
/// <param name="width">New width</param>
/// <param name="height">New height</param>
////////////////////////////////////////////////////////////
public virtual void SetSize(uint width, uint height)
{
sfWindow_SetSize(This, width, height);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Show or hide the window
/// </summary>
/// <param name="show">True to show, false to hide</param>
////////////////////////////////////////////////////////////
public virtual void Show(bool show)
{
sfWindow_Show(This, show);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Enable or disable automatic key-repeat.
/// Automatic key-repeat is enabled by default
/// </summary>
/// <param name="enable">True to enable, false to disable</param>
////////////////////////////////////////////////////////////
public virtual void EnableKeyRepeat(bool enable)
{
sfWindow_EnableKeyRepeat(This, enable);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the window's icon
/// </summary>
/// <param name="width">Icon's width, in pixels</param>
/// <param name="height">Icon's height, in pixels</param>
/// <param name="pixels">Array of pixels, format must be RGBA 32 bits</param>
////////////////////////////////////////////////////////////
public virtual void SetIcon(uint width, uint height, byte[] pixels)
{
unsafe
{
fixed (byte* PixelsPtr = pixels)
{
sfWindow_SetIcon(This, width, height, PixelsPtr);
}
}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Activate the window as the current target
/// for rendering
/// </summary>
/// <returns>True if operation was successful, false otherwise</returns>
////////////////////////////////////////////////////////////
public virtual bool SetActive()
{
return SetActive(true);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Activate of deactivate the window as the current target
/// for rendering
/// </summary>
/// <param name="active">True to activate, false to deactivate (true by default)</param>
/// <returns>True if operation was successful, false otherwise</returns>
////////////////////////////////////////////////////////////
public virtual bool SetActive(bool active)
{
return sfWindow_SetActive(This, active);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Limit the framerate to a maximum fixed frequency
/// </summary>
/// <param name="limit">Framerate limit, in frames per seconds (use 0 to disable limit)</param>
////////////////////////////////////////////////////////////
public virtual void SetFramerateLimit(uint limit)
{
sfWindow_SetFramerateLimit(This, limit);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get time elapsed since last frame
/// </summary>
/// <returns>Time elapsed, in seconds</returns>
////////////////////////////////////////////////////////////
public virtual float GetFrameTime()
{
return sfWindow_GetFrameTime(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the joystick threshold, ie. the value below which
/// no move event will be generated
/// </summary>
/// <param name="threshold">New threshold, in range [0, 100]</param>
////////////////////////////////////////////////////////////
public virtual void SetJoystickThreshold(float threshold)
{
sfWindow_SetJoystickThreshold(This, threshold);
}
////////////////////////////////////////////////////////////
/// <summary>
/// OS-specific handle of the window
/// </summary>
////////////////////////////////////////////////////////////
public virtual IntPtr SystemHandle
{
get {return sfWindow_GetSystemHandle(This);}
}
////////////////////////////////////////////////////////////
/// <summary>
/// Wait for a new event and dispatch it to the corresponding
/// event handler
/// </summary>
////////////////////////////////////////////////////////////
public void WaitAndDispatchEvents()
{
Event e;
if (WaitEvent(out e))
CallEventHandler(e);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Call the event handlers for each pending event
/// </summary>
////////////////////////////////////////////////////////////
public void DispatchEvents()
{
Event e;
while (GetEvent(out e))
CallEventHandler(e);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Window]" +
" Width(" + Width + ")" +
" Height(" + Height + ")" +
" Settings(" + Settings + ")";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Constructor for derived classes
/// </summary>
/// <param name="thisPtr">Pointer to the internal object</param>
/// <param name="dummy">Internal hack :)</param>
////////////////////////////////////////////////////////////
protected Window(IntPtr thisPtr, int dummy) :
base(thisPtr)
{
// TODO : find a cleaner way of separating this constructor from Window(IntPtr handle)
}
////////////////////////////////////////////////////////////
/// <summary>
/// Internal function to get the next event (non-blocking)
/// </summary>
/// <param name="eventToFill">Variable to fill with the raw pointer to the event structure</param>
/// <returns>True if there was an event, false otherwise</returns>
////////////////////////////////////////////////////////////
protected virtual bool GetEvent(out Event eventToFill)
{
return sfWindow_GetEvent(This, out eventToFill);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Internal function to get the next event (blocking)
/// </summary>
/// <param name="eventToFill">Variable to fill with the raw pointer to the event structure</param>
/// <returns>False if any error occured</returns>
////////////////////////////////////////////////////////////
protected virtual bool WaitEvent(out Event eventToFill)
{
return sfWindow_WaitEvent(This, out eventToFill);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
sfWindow_Destroy(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Call the event handler for the given event
/// </summary>
/// <param name="e">Event to dispatch</param>
////////////////////////////////////////////////////////////
private void CallEventHandler(Event e)
{
switch (e.Type)
{
case EventType.Closed :
if (Closed != null)
Closed(this, EventArgs.Empty);
break;
case EventType.GainedFocus :
if (GainedFocus != null)
GainedFocus(this, EventArgs.Empty);
break;
case EventType.JoyButtonPressed :
if (JoyButtonPressed != null)
JoyButtonPressed(this, new JoyButtonEventArgs(e.JoyButton));
break;
case EventType.JoyButtonReleased :
if (JoyButtonReleased != null)
JoyButtonReleased(this, new JoyButtonEventArgs(e.JoyButton));
break;
case EventType.JoyMoved :
if (JoyMoved != null)
JoyMoved(this, new JoyMoveEventArgs(e.JoyMove));
break;
case EventType.KeyPressed :
if (KeyPressed != null)
KeyPressed(this, new KeyEventArgs(e.Key));
break;
case EventType.KeyReleased :
if (KeyReleased != null)
KeyReleased(this, new KeyEventArgs(e.Key));
break;
case EventType.LostFocus :
if (LostFocus != null)
LostFocus(this, EventArgs.Empty);
break;
case EventType.MouseButtonPressed :
if (MouseButtonPressed != null)
MouseButtonPressed(this, new MouseButtonEventArgs(e.MouseButton));
break;
case EventType.MouseButtonReleased :
if (MouseButtonReleased != null)
MouseButtonReleased(this, new MouseButtonEventArgs(e.MouseButton));
break;
case EventType.MouseEntered :
if (MouseEntered != null)
MouseEntered(this, EventArgs.Empty);
break;
case EventType.MouseLeft :
if (MouseLeft != null)
MouseLeft(this, EventArgs.Empty);
break;
case EventType.MouseMoved :
if (MouseMoved != null)
MouseMoved(this, new MouseMoveEventArgs(e.MouseMove));
break;
case EventType.MouseWheelMoved :
if (MouseWheelMoved != null)
MouseWheelMoved(this, new MouseWheelEventArgs(e.MouseWheel));
break;
case EventType.Resized :
if (Resized != null)
Resized(this, new SizeEventArgs(e.Size));
break;
case EventType.TextEntered :
if (TextEntered != null)
TextEntered(this, new TextEventArgs(e.Text));
break;
}
}
/// <summary>Event handler for the Closed event</summary>
public event EventHandler Closed = null;
/// <summary>Event handler for the Resized event</summary>
public event EventHandler<SizeEventArgs> Resized = null;
/// <summary>Event handler for the LostFocus event</summary>
public event EventHandler LostFocus = null;
/// <summary>Event handler for the GainedFocus event</summary>
public event EventHandler GainedFocus = null;
/// <summary>Event handler for the TextEntered event</summary>
public event EventHandler<TextEventArgs> TextEntered = null;
/// <summary>Event handler for the KeyPressed event</summary>
public event EventHandler<KeyEventArgs> KeyPressed = null;
/// <summary>Event handler for the KeyReleased event</summary>
public event EventHandler<KeyEventArgs> KeyReleased = null;
/// <summary>Event handler for the MouseWheelMoved event</summary>
public event EventHandler<MouseWheelEventArgs> MouseWheelMoved = null;
/// <summary>Event handler for the MouseButtonPressed event</summary>
public event EventHandler<MouseButtonEventArgs> MouseButtonPressed = null;
/// <summary>Event handler for the MouseButtonReleased event</summary>
public event EventHandler<MouseButtonEventArgs> MouseButtonReleased = null;
/// <summary>Event handler for the MouseMoved event</summary>
public event EventHandler<MouseMoveEventArgs> MouseMoved = null;
/// <summary>Event handler for the MouseEntered event</summary>
public event EventHandler MouseEntered = null;
/// <summary>Event handler for the MouseLeft event</summary>
public event EventHandler MouseLeft = null;
/// <summary>Event handler for the JoyButtonPressed event</summary>
public event EventHandler<JoyButtonEventArgs> JoyButtonPressed = null;
/// <summary>Event handler for the JoyButtonReleased event</summary>
public event EventHandler<JoyButtonEventArgs> JoyButtonReleased = null;
/// <summary>Event handler for the JoyMoved event</summary>
public event EventHandler<JoyMoveEventArgs> JoyMoved = null;
protected Input myInput = null;
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfWindow_Create(VideoMode Mode, string Title, Styles Style, ref ContextSettings Params);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfWindow_CreateFromHandle(IntPtr Handle, ref ContextSettings Params);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_Destroy(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfWindow_GetInput(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfWindow_IsOpened(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_Close(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfWindow_GetEvent(IntPtr This, out Event Evt);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfWindow_WaitEvent(IntPtr This, out Event Evt);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_Display(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfWindow_GetWidth(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfWindow_GetHeight(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern ContextSettings sfWindow_GetSettings(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_UseVerticalSync(IntPtr This, bool Enable);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_ShowMouseCursor(IntPtr This, bool Show);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_SetCursorPosition(IntPtr This, uint X, uint Y);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_SetPosition(IntPtr This, int X, int Y);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_SetSize(IntPtr This, uint Width, uint Height);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_Show(IntPtr This, bool Show);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_EnableKeyRepeat(IntPtr This, bool Enable);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
unsafe static extern void sfWindow_SetIcon(IntPtr This, uint Width, uint Height, byte* Pixels);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfWindow_SetActive(IntPtr This, bool Active);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_SetFramerateLimit(IntPtr This, uint Limit);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfWindow_GetFrameTime(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_SetJoystickThreshold(IntPtr This, float Threshold);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfWindow_GetSystemHandle(IntPtr This);
#endregion
}
}
}

63
bindings/dotnet/src/Window/sfml-window.csproj Normal file
View file

@ -0,0 +1,63 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{D17DE83D-A592-461F-8AF2-53F9E22E1D0F}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>SFML.Window</RootNamespace>
<AssemblyName>sfmlnet-window-2</AssemblyName>
<StartupObject>
</StartupObject>
<FileUpgradeFlags>
</FileUpgradeFlags>
<OldToolsVersion>2.0</OldToolsVersion>
<UpgradeBackupLocation>
</UpgradeBackupLocation>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>..\..\lib\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<DocumentationFile>..\..\doc\build\window-doc.xml</DocumentationFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>..\..\lib\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<DocumentationFile>..\..\doc\build\window-doc.xml</DocumentationFile>
</PropertyGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<ItemGroup>
<Compile Include="ContextSettings.cs" />
<Compile Include="Event.cs" />
<Compile Include="EventArgs.cs" />
<Compile Include="Input.cs" />
<Compile Include="LoadingFailedException.cs" />
<Compile Include="ObjectBase.cs" />
<Compile Include="VideoMode.cs" />
<Compile Include="Window.cs" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>