Edgaru089/SFML
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit in a series to change property functions into D style

Browse Source 
git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1454 4e206d99-4929-0410-ac5d-dfc041789085
This commit is contained in:
trass3r 2010-03-13 01:56:39 +00:00
parent 809b09292f
commit 1c72b919e7
5 changed files with 443 additions and 460 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
DSFML/import/dsfml/audio/sound.d
View File

@ -51,7 +51,7 @@ class Sound : SoundSource!("sfSound")
* Construct the sound from its parameters
*
* Params:
* buffer = Sound buffer to play
* soundbuffer = Sound buffer to play
* loop = Loop flag (false by default)
* pitch = Value of the pitch (1 by default)
* volume = Volume (100 by default)
@ -62,16 +62,16 @@ class Sound : SoundSource!("sfSound")
* Throws:
* NullParameterException if buffer is null
*/
this(SoundBuffer buffer, bool loop = false, float pitch = 1.f, float volume = 100.f, float x = 0.f, float y = 0.f, float z = 0.f)
this(SoundBuffer soundbuffer, bool loop = false, float pitch = 1.f, float volume = 100.f, float x = 0.f, float y = 0.f, float z = 0.f)
{
if (buffer is null)
if (soundbuffer is null)
throw new NullParameterException("NullParameterException : SoundBuffer is null.");
super();
setBuffer(buffer);
setLoop(loop);
setPitch(pitch);
setVolume(volume);
buffer = soundbuffer;
loop = loop;
pitch = pitch;
volume = volume;
setPosition(x, y, z);
}
@ -100,13 +100,15 @@ class Sound : SoundSource!("sfSound")
sfSound_Stop(m_ptr);
}
@property
{
/**
* Set the source buffer
*
* Params:
* buffer = New sound buffer to bind to the sound
*/
void setBuffer(SoundBuffer buffer)
void buffer(SoundBuffer buffer)
{
if (buffer is null)
throw new NullParameterException("NullParameterException : SoundBuffer is null.");
@ -122,7 +124,7 @@ class Sound : SoundSource!("sfSound")
* Params:
* loop = True to play in loop, false to play once
*/
void setLoop(bool loop)
void loop(bool loop)
{
sfSound_SetLoop(m_ptr, loop);
}
@ -133,7 +135,7 @@ class Sound : SoundSource!("sfSound")
* Params:
* offset = new playing position, expressed in seconds
*/
void setPlayingOffset(float offset)
void playingOffset(float offset)
{
sfSound_SetPlayingOffset(m_ptr, offset);
}
@ -145,7 +147,7 @@ class Sound : SoundSource!("sfSound")
* Returns:
* Sound buffer bound to the sound (can be NULL)
*/
SoundBuffer getBuffer()
SoundBuffer buffer()
{
return m_buffer;
}
@ -156,7 +158,7 @@ class Sound : SoundSource!("sfSound")
* Returns:
* True if the sound is looping, false otherwise
*/
bool getLoop()
bool loop()
{
return cast(bool)(sfSound_GetLoop(m_ptr));
@ -168,10 +170,11 @@ class Sound : SoundSource!("sfSound")
* Returns:
* Current playing position, expressed in seconds
*/
float getPlayingOffset()
float playingOffset()
{
return sfSound_GetPlayingOffset(m_ptr);
}
}
private:
SoundBuffer m_buffer;

73
DSFML/import/dsfml/audio/soundbuffer.d
View File

@ -83,7 +83,7 @@ class SoundBuffer : DSFMLObject
* Throws:
* LoadingException on failure
*/
this(short[] samples, uint channelsCount, uint sampleRate)
this(const(short)[] samples, uint channelsCount, uint sampleRate)
{
if (samples is null || samples.length == 0)
throw new Exception("LoadingException : Samples array is invalid.");
@ -116,18 +116,20 @@ class SoundBuffer : DSFMLObject
return false;
}
@property
{
/**
* Return the sound samples
*
* Returns:
* Array of sound samples, in 16 bits signed integer format
*/
short[] getSamples()
short[] samples()
{
short* temp = null;
temp = sfSoundBuffer_GetSamples(m_ptr);
return temp is null ? null : temp[0..getSamplesCount];
return temp is null ? null : temp[0..samplesCount()];
}
/**
@ -136,7 +138,7 @@ class SoundBuffer : DSFMLObject
* Returns:
* Number of samples
*/
size_t getSamplesCount()
size_t samplesCount()
{
return sfSoundBuffer_GetSamplesCount(m_ptr);
}
@ -147,7 +149,7 @@ class SoundBuffer : DSFMLObject
* Returns:
* Sound frequency (number of samples per second)
*/
uint getSampleRate()
uint sampleRate()
{
return sfSoundBuffer_GetSampleRate(m_ptr);
}
@ -158,7 +160,7 @@ class SoundBuffer : DSFMLObject
* Returns:
* Number of channels
*/
uint getChannelsCount()
uint channelsCount()
{
return sfSoundBuffer_GetChannelsCount(m_ptr);
}
@ -169,10 +171,11 @@ class SoundBuffer : DSFMLObject
* Returns:
* Sound duration, in seconds
*/
float getDuration()
float duration()
{
return sfSoundBuffer_GetDuration(m_ptr);
}
}
package:
this(void* ptr)
@ -181,50 +184,22 @@ package:
}
private:
// External ====================================================================
extern (C)
static extern(C)
{
typedef void* function(cchar*) pf_sfSoundBuffer_CreateFromFile;
typedef void* function(byte*, size_t) pf_sfSoundBuffer_CreateFromMemory;
typedef void* function(short*, size_t, uint, uint) pf_sfSoundBuffer_CreateFromSamples;
typedef void function(void*) pf_sfSoundBuffer_Destroy;
typedef int function(void*, cchar*) pf_sfSoundBuffer_SaveToFile;
typedef short* function(void*) pf_sfSoundBuffer_GetSamples;
typedef size_t function(void*) pf_sfSoundBuffer_GetSamplesCount;
typedef uint function(void*) pf_sfSoundBuffer_GetSampleRate;
typedef uint function(void*) pf_sfSoundBuffer_GetChannelsCount;
typedef float function(void*) pf_sfSoundBuffer_GetDuration;
static pf_sfSoundBuffer_CreateFromFile sfSoundBuffer_CreateFromFile;
static pf_sfSoundBuffer_CreateFromMemory sfSoundBuffer_CreateFromMemory;
static pf_sfSoundBuffer_CreateFromSamples sfSoundBuffer_CreateFromSamples;
static pf_sfSoundBuffer_Destroy sfSoundBuffer_Destroy;
static pf_sfSoundBuffer_SaveToFile sfSoundBuffer_SaveToFile;
static pf_sfSoundBuffer_GetSamples sfSoundBuffer_GetSamples;
static pf_sfSoundBuffer_GetSamplesCount sfSoundBuffer_GetSamplesCount;
static pf_sfSoundBuffer_GetSampleRate sfSoundBuffer_GetSampleRate;
static pf_sfSoundBuffer_GetChannelsCount sfSoundBuffer_GetChannelsCount;
static pf_sfSoundBuffer_GetDuration sfSoundBuffer_GetDuration;
void* function(cchar*) sfSoundBuffer_CreateFromFile;
void* function(const(byte)*, size_t) sfSoundBuffer_CreateFromMemory;
void* function(const(short)*, size_t, uint, uint) sfSoundBuffer_CreateFromSamples;
void function(void*) sfSoundBuffer_Destroy;
int function(void*, cchar*) sfSoundBuffer_SaveToFile;
short* function(void*) sfSoundBuffer_GetSamples;
size_t function(void*) sfSoundBuffer_GetSamplesCount;
uint function(void*) sfSoundBuffer_GetSampleRate;
uint function(void*) sfSoundBuffer_GetChannelsCount;
float function(void*) sfSoundBuffer_GetDuration;
}
static this()
{
debug
DllLoader dll = DllLoader.load("csfml-audio-d");
else
DllLoader dll = DllLoader.load("csfml-audio");
sfSoundBuffer_CreateFromFile = cast(pf_sfSoundBuffer_CreateFromFile)dll.getSymbol("sfSoundBuffer_CreateFromFile");
sfSoundBuffer_CreateFromMemory = cast(pf_sfSoundBuffer_CreateFromMemory)dll.getSymbol("sfSoundBuffer_CreateFromMemory");
sfSoundBuffer_CreateFromSamples = cast(pf_sfSoundBuffer_CreateFromSamples)dll.getSymbol("sfSoundBuffer_CreateFromSamples");
sfSoundBuffer_Destroy = cast(pf_sfSoundBuffer_Destroy)dll.getSymbol("sfSoundBuffer_Destroy");
sfSoundBuffer_SaveToFile = cast(pf_sfSoundBuffer_SaveToFile)dll.getSymbol("sfSoundBuffer_SaveToFile");
sfSoundBuffer_GetSamples = cast(pf_sfSoundBuffer_GetSamples)dll.getSymbol("sfSoundBuffer_GetSamples");
sfSoundBuffer_GetSamplesCount = cast(pf_sfSoundBuffer_GetSamplesCount)dll.getSymbol("sfSoundBuffer_GetSamplesCount");
sfSoundBuffer_GetSampleRate = cast(pf_sfSoundBuffer_GetSampleRate)dll.getSymbol("sfSoundBuffer_GetSampleRate");
sfSoundBuffer_GetChannelsCount = cast(pf_sfSoundBuffer_GetChannelsCount)dll.getSymbol("sfSoundBuffer_GetChannelsCount");
sfSoundBuffer_GetDuration = cast(pf_sfSoundBuffer_GetDuration)dll.getSymbol("sfSoundBuffer_GetDuration");
mixin(loadFromSharedLib2("csfml-audio", "sfSoundBuffer",
"CreateFromFile", "CreateFromMemory", "CreateFromSamples", "Destroy", "SaveToFile", "GetSamples", "GetSamplesCount",
"GetSampleRate", "GetChannelsCount", "GetDuration"));
}
}

444
DSFML/import/dsfml/audio/soundsource.d
View File

@ -1,11 +1,35 @@
/**
/*
* DSFML - SFML Library wrapper for the D programming language.
* Copyright (C) 2010 Andreas Hollandt
*
* This software is provided 'as-is', without any express or
* implied warranty. In no event will the authors be held
* liable for any damages arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute
* it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented;
* you must not claim that you wrote the original software.
* If you use this software in a product, an acknowledgment
* in the product documentation would be appreciated but
* is not required.
*
* 2. Altered source versions must be plainly marked as such,
* and must not be misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any
* source distribution.
*/
module dsfml.audio.soundsource;
import dsfml.system.vector3;
import dsfml.system.common;
/// the sound's current status
enum SoundStatus
{
Stopped, /// Sound is not playing
@ -14,17 +38,16 @@ enum SoundStatus
}
/// base class
package class SoundSource(alias symbol) : DSFMLObject
package class SoundSource(alias derivedClassName) : DSFMLObject
{
private:
protected:
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
/// This constructor is meant ot be called by derived classes only.
///
////////////////////////////////////////////////////////////
/**
* Default constructor
*
* This constructor is meant ot be called by derived classes only.
*
*/
this()
{
super(sfSoundSource_Create());
@ -35,49 +58,80 @@ protected :
super(ptr);
}
////////////////////////////////////////////////////////////
/// \brief Get the current status of the sound (stopped, paused, playing)
///
/// \return Current status of the sound
///
////////////////////////////////////////////////////////////
SoundStatus getStatus()
override void dispose()
{
sfSoundSource_Destroy(m_ptr);
}
public:
/**
* Set the 3D position of the sound in the audio scene
*
* Only sounds with one channel (mono sounds) can be spatialized.
* The default position of a sound is (0, 0, 0).
*
* Params:
* x = X coordinate of the position of the sound in the scene
* y = Y coordinate of the position of the sound in the scene
* z = Z coordinate of the position of the sound in the scene
*/
void setPosition(float x, float y, float z)
{
sfSoundSource_SetPosition(m_ptr, x, y, z);
}
@property
{
/**
* Get the current status of the sound (stopped, paused, playing)
*
* Returns:
* current status of the sound
*/
SoundStatus status()
{
return sfSoundSource_GetStatus(m_ptr);
}
public:
////////////////////////////////////////////////////////////
/// \brief Set the pitch of the sound
///
/// The pitch represents the perceived fundamental frequency
/// of a sound; thus you can make a sound more acute or grave
/// by changing its pitch. A side effect of changing the pitch
/// is to modify the playing speed of the sound as well.
/// The default value for the pitch is 1.
///
/// \param pitch New pitch to apply to the sound
///
/// \see GetPitch
///
////////////////////////////////////////////////////////////
void setPitch(float pitch)
/**
* Set the pitch of the sound
*
* The pitch represents the perceived fundamental frequency
* of a sound; thus you can make a sound more acute or grave
* by changing its pitch. A side effect of changing the pitch
* is to modify the playing speed of the sound as well.
* The default value for the pitch is 1.
*
* Params:
* pitch = New pitch to apply to the sound
*/
void pitch(float pitch)
{
sfSoundSource_SetPitch(m_ptr, pitch);
}
////////////////////////////////////////////////////////////
/// \brief Set the volume of the sound
///
/// The volume is a value between 0 (mute) and 100 (full volume).
/// The default value for the volume is 100.
///
/// \param volume Volume of the sound
///
/// \see GetVolume
///
////////////////////////////////////////////////////////////
void setVolume(float volume)
/**
* Get the pitch of the sound
*
* Returns:
* pitch of the sound
*/
float pitch()
{
return sfSoundSource_GetPitch(m_ptr);
}
/**
* Set the volume of the sound
*
* The volume is a value between 0 (mute) and 100 (full volume).
* The default value for the volume is 100.
*
* Params:
* volume = volume of the sound
*/
void volume(float volume)
in
{
assert(volume >= 0 && volume <= 100);
@ -87,137 +141,38 @@ public:
sfSoundSource_SetVolume(m_ptr, volume);
}
////////////////////////////////////////////////////////////
/// \brief Set the 3D position of the sound in the audio scene
///
/// Only sounds with one channel (mono sounds) can be
/// spatialized.
/// The default position of a sound is (0, 0, 0).
///
/// \param x X coordinate of the position of the sound in the scene
/// \param y Y coordinate of the position of the sound in the scene
/// \param z Z coordinate of the position of the sound in the scene
///
/// \see GetPosition
///
////////////////////////////////////////////////////////////
void setPosition(float x, float y, float z)
{
sfSoundSource_SetPosition(m_ptr, x, y, z);
}
////////////////////////////////////////////////////////////
/// \brief Set the 3D position of the sound in the audio scene
///
/// Only sounds with one channel (mono sounds) can be
/// spatialized.
/// The default position of a sound is (0, 0, 0).
///
/// \param position Position of the sound in the scene
///
/// \see GetPosition
///
////////////////////////////////////////////////////////////
void setPosition(Vector3f position)
{
sfSoundSource_SetPosition(m_ptr, position.x, position.y, position.z);
}
////////////////////////////////////////////////////////////
/// \brief Make the sound's position relative to the listener or absolute
///
/// Making a sound relative to the listener will ensure that it will always
/// be played the same way regardless the position of the listener.
/// This can be useful for non-spatialized sounds, sounds that are
/// produced by the listener, or sounds attached to it.
/// The default value is false (position is absolute).
///
/// \param relative True to set the position relative, false to set it absolute
///
/// \see IsRelativeToListener
///
////////////////////////////////////////////////////////////
void setRelativeToListener(bool relative)
{
sfSoundSource_SetRelativeToListener(m_ptr, relative);
}
////////////////////////////////////////////////////////////
/// \brief Set the minimum distance of the sound
///
/// The "minimum distance" of a sound is the maximum
/// distance at which it is heard at its maximum volume. Further
/// than the minimum distance, it will start to fade out according
/// to its attenuation factor. A value of 0 ("inside the head
/// of the listener") is an invalid value and is forbidden.
/// The default value of the minimum distance is 1.
///
/// \param distance New minimum distance of the sound
///
/// \see GetMinDistance, SetAttenuation
///
////////////////////////////////////////////////////////////
void setMinDistance(float distance)
{
sfSoundSource_SetMinDistance(m_ptr, distance);
}
////////////////////////////////////////////////////////////
/// \brief Set the attenuation factor of the sound
///
/// The attenuation is a multiplicative factor which makes
/// the sound more or less loud according to its distance
/// from the listener. An attenuation of 0 will produce a
/// non-attenuated sound, i.e. its volume will always be the same
/// whether it is heard from near or from far. On the other hand,
/// an attenuation value such as 100 will make the sound fade out
/// very quickly as it gets further from the listener.
/// The default value of the attenuation is 1.
///
/// \param attenuation New attenuation factor of the sound
///
/// \see GetAttenuation, SetMinDistance
///
////////////////////////////////////////////////////////////
void setAttenuation(float attenuation)
{
sfSoundSource_SetAttenuation(m_ptr, attenuation);
}
////////////////////////////////////////////////////////////
/// \brief Get the pitch of the sound
///
/// \return Pitch of the sound
///
/// \see SetPitch
///
////////////////////////////////////////////////////////////
float GetPitch()
{
return sfSoundSource_GetPitch(m_ptr);
}
////////////////////////////////////////////////////////////
/// \brief Get the volume of the sound
///
/// \return Volume of the sound, in the range [0, 100]
///
/// \see SetVolume
///
////////////////////////////////////////////////////////////
float GetVolume()
/**
* Get the volume of the sound
*
* Returns:
* Volume of the sound, in the range [0, 100]
*/
float volume()
{
return sfSoundSource_GetVolume(m_ptr);
}
////////////////////////////////////////////////////////////
/// \brief Get the 3D position of the sound in the audio scene
///
/// \return Position of the sound
///
/// \see SetPosition
///
////////////////////////////////////////////////////////////
/**
* Set the 3D position of the sound in the audio scene
*
* Only sounds with one channel (mono sounds) can be
* spatialized.
* The default position of a sound is (0, 0, 0).
*
* Params:
* position = Position of the sound in the scene
*/
void position(Vector3f position)
{
sfSoundSource_SetPosition(m_ptr, position.x, position.y, position.z);
}
/**
* Get the 3D position of the sound in the audio scene
*
* Returns:
* Position of the sound
*/
Vector3f getPosition()
{
Vector3f ret;
@ -225,51 +180,108 @@ public:
return ret;
}
////////////////////////////////////////////////////////////
/// \brief Tell whether the sound's position is relative to the
/// listener or is absolute
///
/// \return True if the position is relative, false if it's absolute
///
/// \see SetRelativeToListener
///
////////////////////////////////////////////////////////////
bool isRelativeToListener()
/**
* Make the sound's position relative to the listener or absolute
*
* Making a sound relative to the listener will ensure that it will always
* be played the same way regardless the position of the listener.
* This can be useful for non-spatialized sounds, sounds that are
* produced by the listener, or sounds attached to it.
* The default value is false (position is absolute).
*
* Params:
* relative = True to set the position relative, false to set it absolute
*/
void relativeToListener(bool relative)
{
sfSoundSource_SetRelativeToListener(m_ptr, relative);
}
/**
* Tell whether the sound's position is relative to the listener or is absolute
*
* Returns:
* True if the position is relative, false if it's absolute
*/
bool relativeToListener()
{
return sfSoundSource_IsRelativeToListener(m_ptr);
}
////////////////////////////////////////////////////////////
/// \brief Get the minimum distance of the sound
///
/// \return Minimum distance of the sound
///
/// \see SetMinDistance, GetAttenuation
///
////////////////////////////////////////////////////////////
float getMinDistance()
/**
* Set the minimum distance of the sound
*
* The "minimum distance" of a sound is the maximum
* distance at which it is heard at its maximum volume. Further
* than the minimum distance, it will start to fade out according
* to its attenuation factor. A value of 0 ("inside the head
* of the listener") is an invalid value and is forbidden.
* The default value of the minimum distance is 1.
*
* Params:
* distance = New minimum distance of the sound
*
* \see GetMinDistance, SetAttenuation
*
*/
void minDistance(float distance)
{
sfSoundSource_SetMinDistance(m_ptr, distance);
}
/**
* Get the minimum distance of the sound
*
* Returns:
* Minimum distance of the sound
*
* \see SetMinDistance, GetAttenuation
*
*/
float minDistance()
{
return sfSoundSource_GetMinDistance(m_ptr);
}
////////////////////////////////////////////////////////////
/// \brief Get the attenuation factor of the sound
///
/// \return Attenuation factor of the sound
///
/// \see SetAttenuation, GetMinDistance
///
////////////////////////////////////////////////////////////
float getAttenuation()
/**
* Set the attenuation factor of the sound
*
* The attenuation is a multiplicative factor which makes
* the sound more or less loud according to its distance
* from the listener. An attenuation of 0 will produce a
* non-attenuated sound, i.e. its volume will always be the same
* whether it is heard from near or from far. On the other hand,
* an attenuation value such as 100 will make the sound fade out
* very quickly as it gets further from the listener.
* The default value of the attenuation is 1.
*
* Params:
* attenuation = New attenuation factor of the sound
*
* \see GetAttenuation, SetMinDistance
*
*/
void attenuation(float attenuation)
{
sfSoundSource_SetAttenuation(m_ptr, attenuation);
}
/**
* Get the attenuation factor of the sound
*
* Returns:
* Attenuation factor of the sound
*
* \see SetAttenuation, GetMinDistance
*
*/
float attenuation()
{
return sfSoundSource_GetAttenuation(m_ptr);
}
override void dispose()
{
sfSoundSource_Destroy(m_ptr);
}
private:
static extern(C)
@ -293,27 +305,7 @@ private:
bool function(void*) sfSoundSource_IsRelativeToListener;
}
static this()
{
debug
DllLoader dll = DllLoader.load("csfml-audio-d");
else
DllLoader dll = DllLoader.load("csfml-audio");
mixin(loadDerivedFromSharedLib("sfSoundSource", "Create", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "Destroy", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "GetStatus", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "GetPitch", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "SetPitch", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "GetVolume", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "SetVolume", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "GetPosition", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "SetPosition", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "GetMinDistance", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "SetMinDistance", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "GetAttenuation", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "SetAttenuation", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "SetRelativeToListener", symbol));
mixin(loadDerivedFromSharedLib("sfSoundSource", "IsRelativeToListener", symbol));
}
mixin(loadDerivedFromSharedLib("csfml-audio", "sfSoundSource", derivedClassName,
"Create", "Destroy", "GetStatus", "GetPitch", "SetPitch", "GetVolume", "SetVolume", "GetPosition", "SetPosition",
"GetMinDistance", "SetMinDistance", "GetAttenuation", "SetAttenuation", "SetRelativeToListener", "IsRelativeToListener"));
}

2
DSFML/import/dsfml/audio/soundstream.d
View File

@ -85,7 +85,7 @@ abstract class SoundStream : SoundSource!("sfSoundStream")
m_flag = true;
sfSoundStream_Play(m_ptr);
if (getStatus() != SoundStatus.Paused)
if (status != SoundStatus.Paused)
{
m_t = new Thread(&threadPoll);
m_t.start();

21
DSFML/import/dsfml/system/common.d
View File

@ -47,7 +47,7 @@ string loadFromSharedLib(string fname)
}
//used to mixin code function
string loadFromSharedLib2(S...)(string lib, string object, S fnames)
string loadFromSharedLib2(S...)(string lib, string className, S fnames)
{
string res = `static this()
{
@ -60,14 +60,27 @@ string loadFromSharedLib2(S...)(string lib, string object, S fnames)
foreach(fname; fnames)
{
res ~= "\t" ~ object ~ "_" ~ fname ~ " = " ~ "cast(typeof(" ~ object ~ "_" ~ fname ~ ")) dll.getSymbol(\"" ~ object ~ "_" ~ fname ~ "\");\n";
res ~= "\t" ~ className ~ "_" ~ fname ~ " = " ~ "cast(typeof(" ~ className ~ "_" ~ fname ~ ")) dll.getSymbol(\"" ~ className ~ "_" ~ fname ~ "\");\n";
}
return res ~ "}\n";
}
string loadDerivedFromSharedLib(string base, string fname, string derived)
string loadDerivedFromSharedLib(S...)(string lib, string baseClass, string derivedClass, S fnames)
{
return base ~ "_" ~ fname ~ " = " ~ "cast(typeof(" ~ base ~ "_" ~ fname ~ ")) dll.getSymbol(\"" ~ derived ~ "_" ~ fname ~ "\");";
string res = `static this()
{
debug
DllLoader dll = DllLoader.load("` ~ lib ~ `-d");
else
DllLoader dll = DllLoader.load("` ~ lib ~ `");
`;
foreach(fname; fnames)
{
res ~= "\t" ~ baseClass ~ "_" ~ fname ~ " = " ~ "cast(typeof(" ~ baseClass ~ "_" ~ fname ~ ")) dll.getSymbol(\"" ~ derivedClass ~ "_" ~ fname ~ "\");";
}
return res ~ "}\n";
}
/**