<![CDATA[DLL in C++ schreiben]]>Ich bin zwar Neuling in Sachen C++, aber ich muss unbedingt eine DLL schreiben.
Also ich fange mal ganz vorne an....
1.Ich habe eine DLL.
2.Zu dieser DLL gibt es zwei .h und zwei .cpp Dateien(die eine bindet die andere ein, also eigentlich eine Datei.
3.Ich muss aus diesem Code, der ja die DLL wrappt wieder eine DLL machen.

Hintergrund ist, daß ich die ursprüngliche DLL, nennen wir sie Ursprung.dll auch mit anderen Programmiersprachen nutzen möchte, es aber immer an einer von zwei Sachen scheitert.Zum einen Wird bei drei Funktionen immer eine Struktur gefüllt, womit nicht jede Sprache immer so einfach klarkommt, und zum anderen gibt es ein Rückgabetypproblem, welches nur zu lösen ist, wenn diese Funktion nur in der Dll verwendet wird.

Im Grunde möchte ich aus dem C++ Code also eine Art Loader.dll für die Ursprung.dll, mit resultierender Vereinfachung der Funktionen die gewrappt werden müssen.

Ich brauch also eigentlich "nur" Hilfe beim Konvertieren des Sourcecodes nach DLL-Konform.

Es handelt sich um etwas über 20 Funktionen, vielleicht tut mir ja jemand den Gefallen und hilft mir dabei.
Allein als C++ Neuling würd ich ewig brauchen, da ich echt erst grad in den Kinderschuhen stecke was C++ anbelangt...

]]>https://www.c-plusplus.net/forum/topic/238014/dll-in-c-schreibenRSS for NodeWed, 23 Sep 2026 04:34:03 GMTSun, 05 Apr 2009 10:03:58 GMT60<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 10:03:58 GMT]]>Ich bin zwar Neuling in Sachen C++, aber ich muss unbedingt eine DLL schreiben.
Also ich fange mal ganz vorne an....
1.Ich habe eine DLL.
2.Zu dieser DLL gibt es zwei .h und zwei .cpp Dateien(die eine bindet die andere ein, also eigentlich eine Datei.
3.Ich muss aus diesem Code, der ja die DLL wrappt wieder eine DLL machen.

Hintergrund ist, daß ich die ursprüngliche DLL, nennen wir sie Ursprung.dll auch mit anderen Programmiersprachen nutzen möchte, es aber immer an einer von zwei Sachen scheitert.Zum einen Wird bei drei Funktionen immer eine Struktur gefüllt, womit nicht jede Sprache immer so einfach klarkommt, und zum anderen gibt es ein Rückgabetypproblem, welches nur zu lösen ist, wenn diese Funktion nur in der Dll verwendet wird.

Im Grunde möchte ich aus dem C++ Code also eine Art Loader.dll für die Ursprung.dll, mit resultierender Vereinfachung der Funktionen die gewrappt werden müssen.

Ich brauch also eigentlich "nur" Hilfe beim Konvertieren des Sourcecodes nach DLL-Konform.

Es handelt sich um etwas über 20 Funktionen, vielleicht tut mir ja jemand den Gefallen und hilft mir dabei.
Allein als C++ Neuling würd ich ewig brauchen, da ich echt erst grad in den Kinderschuhen stecke was C++ anbelangt...

]]>https://www.c-plusplus.net/forum/post/1691138https://www.c-plusplus.net/forum/post/1691138Sun, 05 Apr 2009 10:03:58 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 10:33:49 GMT]]>Ich verstehe dein Problem nicht. Vielleicht kannst den Problem- Teil deines Sourcecodes mal posten.

Simon

]]>https://www.c-plusplus.net/forum/post/1691147https://www.c-plusplus.net/forum/post/1691147Sun, 05 Apr 2009 10:33:49 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 11:06:46 GMT]]>Naja Problemteil ist es in C++ ja nicht.
Es wird nur zum Problem, wenn man versucht diesen code in eine andere Sprache zu konvertieren.
Der einzige Weg im Moment und wohl auch schwerste für mich liegt darin, eine DLL zu erstellen.

Ich poste mal den kompletten source...

FIXorsBridge.h...

#ifndef __FIXORSBRIDGE__
#define __FIXORSBRIDGE__

//##################################################
//						Defines
//##################################################

#define FIXCALL _stdcall

//	CreateImageEx Flags 
#define FI_AUTOFLAGS -1
#define FI_NONE 0
#define FI_MIDHANDLE 1
#define FI_FILTEREDIMAGE 2
#define FI_FILTERED 2

//	SetBlend Flags 
#define FI_SOLIDBLEND 0
#define FI_ALPHABLEND 1
#define FI_LIGHTBLEND 2
#define FI_SHADEBLEND 3
#define FI_MASKBLEND 4
#define FI_MASKBLEND2 5
#define FI_INVALPHABLEND 6

//	ImageFonts Flags
#define FI_SMOOTHFONT 1

//	DrawImagePart Wrap Flags
#define FI_NOWRAP 0
#define FI_WRAPU 1
#define FI_MIRRORU 2
#define FI_WRAPV 4
#define FI_MORRORV 8
#define FI_WRAPUV 5
#define FI_MIRRORUV 10

//	DrawPoly consts
#define FI_POINTLIST 1
#define FI_LINELIST 2
#define FI_LINESTRIP 3
#define FI_TRIANGLELIST 4
#define FI_TRIANGLESTRIP 5
#define FI_TRIANGLEFAN 6 

#define FI_COLOROVERLAY 1

//##################################################
//					 FastImage
//##################################################

struct sFI_Property {
	int Blend;
	float Alpha;
	int Red, Green, Blue;
	int ColorVertex0, ColorVertex1, ColorVertex2, ColorVertex3;
	float Rotation, ScaleX, ScaleY;
	float MatrixXX, MatrixXY, MatrixYX, MatrixYY;
	int HandleX, HandleY;
	int OriginX, OriginY;
	int AutoHandle, AutoFlags;
	float LineWidth;
	int ViewportX, ViewportY, ViewportWidth, ViewportHeight;
	int MipLevel;
	float ProjScaleX, ProjScaleY, ProjRotation;
	int ProjOriginX, ProjOriginY;
	int ProjHandleX, ProjHandleY;
	int Reserved0,Reserved1;
};

struct sFI_ImageProperty {
	int HandleX;
	int HandleY;
	int Width;
	int Height;
	int Frames;
	int Flags;
	int Texture;
	int Reserved0;
	int Reserved1;
};

struct sFI_FontProperty {
	int Width,Height,FirstChar,Kerning;
	int Image,FrameWidth,FrameHeight,FrameCount;
	int* Chars;

	//sFI_FontProperty() { Chars = new int[256]; }
	//~sFI_FontProperty() { delete Chars; }
};

struct sFI_Test {
	int Result;
	int ProjectedX, ProjectedY;
	int RectX, RectY;
	float RectU, RectV;
	int TextureX, TextureY;
	int Texture;
	int Frame;
	int Reserved1;
};

struct sFI_Surfaces {
	int Count;
	int* Array;
	int Texture;
};

//##################################################
//			 FastImage
//##################################################

class cFIXorsBridge {
private:
	/* Singleton - 
	static cFIXorsBridge* vsSelf;
	/* Singleton - 
	static int vsRefcount;

	/*  FastImageXors.dll */
	void* HandleDLL;

	/*  FastImageXors.dll */
	bool LoadFastImage();

	/*  FastImageXors.dll */
	int (FIXCALL*pInitDraw)(int Direct3DDevice9, int reserved);
	int (FIXCALL*pDeinitDraw)();
	int (FIXCALL*pStartDraw)();
	int (FIXCALL*pEndDraw)();
	int (FIXCALL*pSetCustomState)(int operation, int value);
	int (FIXCALL*pSetCustomTextureState)(int operation, int value);
	int (FIXCALL*pSetMipLevel)(int level);
	int (FIXCALL*pSetBlend)(int blend);
	int (FIXCALL*pSetAlpha)(float alpha);
	int (FIXCALL*pSetColor)(int r, int g, int b);
	int (FIXCALL*pSetCustomColor)(int colorVertex0, int colorVertex1, int colorVertex2, int colorVertex3);
	int (FIXCALL*pSetRotation)(float rotation);
	int (FIXCALL*pSetScale)(float scaleX, float scaleY);
	int (FIXCALL*pSetTransform)(float rotation, float scaleX, float scaleY);
	int (FIXCALL*pSetMatrix)(float xx, float xy, float yx, float yy);
	int (FIXCALL*pSetHandle)(int x, int y);
	int (FIXCALL*pSetOrigin)(int x, int y);
	int (FIXCALL*pMidHandleImage)(int image);
	int (FIXCALL*pSetImageHandle)(int image, int x, int y);
	int (FIXCALL*pAutoMidHandleEx)(int state);
	int (FIXCALL*pAutoImageFlags)(int flags);
	int (FIXCALL*pSetLineWidth)(float width);
	int (FIXCALL*pSetViewport)(int x, int y, int width, int height);
	int (FIXCALL*pCreateImageEx)(void* texures, int width, int height, int flags);
	int (FIXCALL*pFreeImageEx)(int image);
	int (FIXCALL*pDrawImageEx)(int image, int x, int y, int frame);
	int (FIXCALL*pDrawImageRectEx)(int image, int x, int y, int width, int height, int frame);
	int (FIXCALL*pDrawImagePart)(int image, int x, int y, int width, int height, int partX, int partY, int partWidth, int partHeight, int frame, int wrap);
	int (FIXCALL*pDrawPoly)(int x, int y, int bank, int image, int frame, int color);
	int (FIXCALL*pDrawRect)(int x, int y, int width, int height, int fill);
	int (FIXCALL*pDrawRectSimple)(int x, int y, int width, int height, int fill);
	int (FIXCALL*pDrawLine)(int x, int y, int x2, int y2);
	int (FIXCALL*pDrawLineSimple)(int x, int y, int x2, int y2);
	int (FIXCALL*pDrawPlot)(int x, int y);
	int (FIXCALL*pDrawOval)(int x, int y, int width, int height);
	int (FIXCALL*pGetProperty)(void* type);
	int (FIXCALL*pGetImageProperty)(int img, void* type);
	int (FIXCALL*pSetProjScale)(int scaleX, int scaleY);
	int (FIXCALL*pSetProjRotation)(float rotation);
	int (FIXCALL*pSetProjTransform)(float rotation, float scaleX, float scaleY);
	int (FIXCALL*pSetProjOrigin)(int x, int y);
	int (FIXCALL*pSetProjHandle)(int x, int y);
	int (FIXCALL*pMidHandleProj)();
	int (FIXCALL*pCreateImageFont)(void* type);
	int (FIXCALL*pSetImageFont)(int font);
	int (FIXCALL*pFreeImageFont)(int font);
	int (FIXCALL*pDrawTextEx)(const char* txt, int x, int y, int centerX, int centerY, int maxWidth);
	int (FIXCALL*pDrawTextRect)(const char* txt, int x, int y, int w, int h, int centerX, int centerY, int lineSpacing);
	int (FIXCALL*pTextRectCount)();
	int (FIXCALL*pTextRectMaxWidth)();
	int (FIXCALL*pTextRectWidth)(int StringNumber);
	int (FIXCALL*pStringWidthEx)(const char* txt, int maxWidth);
	int (FIXCALL*pStringHeightEx)(const char* txt);
	int (FIXCALL*pGetFontProperty)(int font, void* type);
	int (FIXCALL*pTestRect)(int xPoint, int yPoint, int xRect, int yRect, int WidthRect, int HeightRect, int Local, void* Result, int ResultFlag);
	int (FIXCALL*pTestOval)(int xPoint, int yPoint, int xOval, int yOval, int WidthOval, int HeightOval, int Local, void* Result, int ResultFlag);
	int (FIXCALL*pTestImage)(int xPoint, int yPoint, int xImage, int yImage, int Image, int Local, void* Result, int ResultFlag);
	int (FIXCALL*pTestRendered)(int xPoint, int yPoint, int Local, void* Result, int ResultFlag);
	int (FIXCALL*pGetCustomTransform)(int type, void* martix);
	int (FIXCALL*pSetCustomTransform)(int type, void* martix);

protected:
	cFIXorsBridge();
	virtual ~cFIXorsBridge();

public:
	/*  FastImage */
	static cFIXorsBridge* Initiate(bool initDraw = true);

	static cFIXorsBridge& GetSingleton() { return *vsSelf; }
	static cFIXorsBridge* GetSingletonPtr() { return vsSelf; }

	void FreeSingleton() { if(--vsRefcount==0) delete this; }

	sFI_Property Property;
	sFI_ImageProperty ImageProperty;
	sFI_FontProperty FontProperty;
	sFI_Test Test;

	int InitDraw();
	int DeinitDraw() { return pDeinitDraw(); }
	int StartDraw() { return pStartDraw(); }
	int EndDraw() { return pEndDraw(); }
	int GetProperty() { return pGetProperty(&Property); }
	int GetImageProperty(int img) { return pGetImageProperty(img, &ImageProperty); }
	int GetFontProperty(int font) { return pGetFontProperty(font, &FontProperty); }

	int SetCustomState(int operation, int value) { return pSetCustomState(operation, value); }
	int SetCustomTextureState(int operation, int value) { return pSetCustomTextureState(operation, value); }
	int SetMipLevel(int level) { return pSetMipLevel(level); }
	int SetBlend(int blend) { return pSetBlend(blend); }
	int SetAlpha(float alpha) { return pSetAlpha(alpha); }
	int SetColor(int r, int g, int b) { return pSetColor(r, g, b); }
	int SetCustomColor(int colorVertex0, int colorVertex1, int colorVertex2, int colorVertex3) { return pSetCustomColor(colorVertex0, colorVertex1, colorVertex2, colorVertex3); }
	int SetRotation(float rotation) { return pSetRotation(rotation); }
	int SetScale(float scaleX, float scaleY) { return pSetScale(scaleX, scaleY); }
	int SetTransform(float rotation, float scaleX, float scaleY) { return pSetTransform(rotation, scaleX, scaleY); }
	int SetMatrix(float xx, float xy, float yx, float yy) { return pSetMatrix(xx, xy, yx, yy); }
	int SetHandle(int x, int y) { return pSetHandle(x, y); }
	int SetOrigin(int x, int y) { return pSetOrigin(x, y); }
	int MidHandleImage(int image) { return pMidHandleImage(image); }
	int SetImageHandle(int image, int x, int y) { return pSetImageHandle(image, x, y); }
	int AutoMidHandleEx(int state) { return pAutoMidHandleEx(state); }
	int AutoImageFlags(int flags) { return pAutoImageFlags(flags); }
	int SetLineWidth(float width) { return pSetLineWidth(width); }
	int SetViewport(int x, int y, int width, int height) { return pSetViewport(x, y, width, height); }
	int SetProjScale(int scaleX, int scaleY) { return pSetProjScale(scaleX, scaleY); }
	int SetProjRotation(float rotation) { return pSetProjRotation(rotation); }
	int SetProjTransform(float rotation, float scaleX, float scaleY) { return pSetProjTransform(rotation, scaleX, scaleY); }
	int SetProjOrigin(int x, int y) { return pSetProjOrigin(x, y); }
	int SetProjHandle(int x, int y) { return pSetProjHandle(x, y); }
	int MidHandleProj() { return pMidHandleProj(); }
	int SetImageFont(int font) { return pSetImageFont(font); }

	int SetCustomBlend(int src, int dest);
	int CreateImage(int texture, int width, int height, int imageFlags = FI_AUTOFLAGS);
	int LoadImageF(const char* fileName, int textureFlags = 0, int imageFlags = FI_AUTOFLAGS);
	int LoadAnimImage(const char* fileName, int textureFlags, int frameWidth, int frameHeight, int firstFrame, int frameCount, int imageFlags = FI_AUTOFLAGS);
	int LoadImageFont(const char* filename, int flags);
	void FreeImage(int image, int freeTexture = 0);
	void FreeImageFont(int font);

	int DrawImage(int image, int x, int y, int frame = 0) { return( pDrawImageEx(image, x, y, frame) ); }
	int DrawImageRect(int image, int x, int y, int width, int height, int frame = 0) { return( pDrawImageRectEx(image, x, y, width, height, frame) ); }
	int DrawImagePart(int image, int x, int y, int width, int height, int partX = 0, int partY = 0, int partWidth = 0, int partHeight = 0, int frame = 0, int wrap = FI_NOWRAP) { return( pDrawImagePart(image, x, y, width, height, partX, partY, partWidth, partHeight, frame, wrap) ); }
	int DrawPoly(int x, int y, int bank, int image = 0, int frame = 0, int color = FI_NONE) { return( pDrawPoly(x, y, bank, image, frame, color) ); }
	int DrawRect(int x, int y, int width, int height, int fill = 1) { return( pDrawRect(x, y, width, height, fill) ); }
	int DrawRectSimple(int x, int y, int width, int height, int fill = 1) { return( pDrawRectSimple(x, y, width, height, fill) ); }
	int DrawLine(int x, int y, int x2, int y2) { return pDrawLine(x, y, x2, y2); }
	int DrawLineSimple(int x, int y, int x2, int y2) { return pDrawLineSimple(x, y, x2,  y2); }
	int DrawPlot(int x, int y) { return pDrawPlot(x, y); }
	int DrawOval(int x, int y, int width, int height) { return pDrawOval(x, y, width, height); }
	int DrawText(const char* txt, int x, int y, int centerX = 0, int centerY = 0, int maxWidth = 10000) { return( pDrawTextEx(txt, x, y, centerX, centerY, maxWidth) ); }
	int DrawTextRect(const char* txt, int x, int y, int w, int h, int centerX = 0, int centerY = 0, int lineSpacing = 0) { return( pDrawTextRect(txt, x, y, w, h, centerX, centerY, lineSpacing) ); }
	int TextRectCount() { return pTextRectCount(); }
	int TextRectMaxWidth() { return pTextRectMaxWidth(); }
	int TextRectWidth(int StringNumber) { return pTextRectWidth(StringNumber); }
	int StringWidth(const char* txt, int maxWidth = 10000) { return pStringWidthEx(txt, maxWidth); }
	int StringHeight(const char* txt) { return pStringHeightEx(txt); }

	int TestRect(int xPoint, int yPoint, int xRect, int yRect, int WidthRect, int HeightRect, int Local = 0) { return( pTestRect(xPoint, yPoint, xRect, yRect, WidthRect, HeightRect, Local, &Test, 1) ); }
	int TestOval(int xPoint, int yPoint, int xOval, int yOval, int WidthOval, int HeightOval, int Local = 0) { return( pTestOval(xPoint, yPoint, xOval, yOval, WidthOval, HeightOval, Local, &Test, 1) ); }
	int TestImage(int xPoint, int yPoint, int xImage, int yImage, int Image, int alphaLevel = 0, int Frame = 0, int Loc = 0);
	int TestRendered(int xPoint, int yPoint, int alphaLevel = 0, int Loc = 0);
	int GetCustomTransform(int type, void* martix) { return pGetCustomTransform(type, martix); }
	int SetCustomTransform(int type, void* martix) { return pSetCustomTransform(type, martix); }
};

#endif /*__FIXORSBRIDGE__*/

und FIXorsBridge.cpp

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <fstream>
#include "FIXorsBridge.h"
#include "GetImageInfo.h"
#include "../x3d/defines.h"
#include "../x3d/texture.h"
#include "../x3d/graphics.h"

using namespace std;

//---------------------------------------------------------------------
cFIXorsBridge* cFIXorsBridge::vsSelf = NULL;
//---------------------------------------------------------------------
int cFIXorsBridge::vsRefcount = 0;
//---------------------------------------------------------------------
cFIXorsBridge::cFIXorsBridge() {
	HandleDLL = 0;
	FontProperty.Chars = new int[256];
}
//---------------------------------------------------------------------
cFIXorsBridge::~cFIXorsBridge() {
	vsSelf = NULL;
	if (HandleDLL) FreeLibrary( (HMODULE)HandleDLL );
	delete[] FontProperty.Chars;
}
//---------------------------------------------------------------------
cFIXorsBridge* cFIXorsBridge::Initiate(bool initDraw) {
		if (!vsSelf) {
		vsSelf = new cFIXorsBridge;
		if ( !vsSelf->LoadFastImage() ) {
			delete vsSelf;
			return NULL;
		}
	}
	if (initDraw) vsSelf->InitDraw();
	vsRefcount++;
	return vsSelf;
}
//---------------------------------------------------------------------
bool cFIXorsBridge::LoadFastImage() {
	HMODULE hLib = LoadLibrary("FastImageXors.dll");
	if (hLib == NULL) { return(false); }
	HandleDLL = (void*)hLib;

	(FARPROC &)pInitDraw = GetProcAddress(hLib, "InitDraw_");
	if (!pInitDraw) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDeinitDraw = GetProcAddress(hLib, "DeinitDraw_");
	if (!pDeinitDraw) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pStartDraw = GetProcAddress(hLib, "StartDraw_");
	if (!pStartDraw) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pEndDraw = GetProcAddress(hLib, "EndDraw_");
	if (!pEndDraw) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetCustomState = GetProcAddress(hLib, "SetCustomState_");
	if (!pSetCustomState) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetCustomTextureState = GetProcAddress(hLib, "SetCustomTextureState_");
	if (!pSetCustomTextureState) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetMipLevel = GetProcAddress(hLib, "SetMipLevel_");
	if (!pSetMipLevel) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetBlend = GetProcAddress(hLib, "SetBlend_");
	if (!pSetBlend) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetAlpha = GetProcAddress(hLib, "SetAlpha_");
	if (!pSetAlpha) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetColor = GetProcAddress(hLib, "SetColor_");
	if (!pSetColor) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetCustomColor = GetProcAddress(hLib, "SetCustomColor_");
	if (!pSetCustomColor) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetRotation = GetProcAddress(hLib, "SetRotation_");
	if (!pSetRotation) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetScale = GetProcAddress(hLib, "SetScale_");
	if (!pSetScale) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetTransform = GetProcAddress(hLib, "SetTransform_");
	if (!pSetTransform) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetMatrix = GetProcAddress(hLib, "SetMatrix_");
	if (!pSetMatrix) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetHandle = GetProcAddress(hLib, "SetHandle_");
	if (!pSetHandle) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetOrigin = GetProcAddress(hLib, "SetOrigin_");
	if (!pSetOrigin) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pMidHandleImage = GetProcAddress(hLib, "MidHandleImage_");
	if (!pMidHandleImage) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetImageHandle = GetProcAddress(hLib, "SetImageHandle_");
	if (!pSetImageHandle) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pAutoMidHandleEx = GetProcAddress(hLib, "AutoMidHandleEx_");
	if (!pAutoMidHandleEx) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pAutoImageFlags = GetProcAddress(hLib, "AutoImageFlags_");
	if (!pAutoImageFlags) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetLineWidth = GetProcAddress(hLib, "SetLineWidth_");
	if (!pSetLineWidth) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetViewport = GetProcAddress(hLib, "SetViewport_");
	if (!pSetViewport) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pCreateImageEx = GetProcAddress(hLib, "CreateImageEx_");
	if (!pCreateImageEx) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pFreeImageEx = GetProcAddress(hLib, "FreeImageEx_");
	if (!pFreeImageEx) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawImageEx = GetProcAddress(hLib, "DrawImageEx_");
	if (!pDrawImageEx) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawImageRectEx = GetProcAddress(hLib, "DrawImageRectEx_");
	if (!pDrawImageRectEx) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawImagePart = GetProcAddress(hLib, "DrawImagePart_");
	if (!pDrawImagePart) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawPoly = GetProcAddress(hLib, "DrawPoly_");
	if (!pDrawPoly) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawRect = GetProcAddress(hLib, "DrawRect_");
	if (!pDrawRect) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawRectSimple = GetProcAddress(hLib, "DrawRectSimple_");
	if (!pDrawRectSimple) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawLine = GetProcAddress(hLib, "DrawLine_");
	if (!pDrawLine) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawLineSimple = GetProcAddress(hLib, "DrawLineSimple_");
	if (!pDrawLineSimple) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawPlot = GetProcAddress(hLib, "DrawPlot_");
	if (!pDrawPlot) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawOval = GetProcAddress(hLib, "DrawOval_");
	if (!pDrawOval) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pGetProperty = GetProcAddress(hLib, "GetProperty_");
	if (!pGetProperty) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pGetImageProperty = GetProcAddress(hLib, "GetImageProperty_");
	if (!pGetImageProperty) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetProjScale = GetProcAddress(hLib, "SetProjScale_");
	if (!pSetProjScale) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetProjRotation = GetProcAddress(hLib, "SetProjRotation_");
	if (!pSetProjRotation) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetProjTransform = GetProcAddress(hLib, "SetProjTransform_");
	if (!pSetProjTransform) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetProjOrigin = GetProcAddress(hLib, "SetProjOrigin_");
	if (!pSetProjOrigin) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetProjHandle = GetProcAddress(hLib, "SetProjHandle_");
	if (!pSetProjHandle) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pMidHandleProj = GetProcAddress(hLib, "MidHandleProj_");
	if (!pMidHandleProj) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pCreateImageFont = GetProcAddress(hLib, "CreateImageFont_");
	if (!pCreateImageFont) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetImageFont = GetProcAddress(hLib, "SetImageFont_");
	if (!pSetImageFont) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pFreeImageFont = GetProcAddress(hLib, "FreeImageFont_");
	if (!pFreeImageFont) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawTextEx = GetProcAddress(hLib, "DrawTextEx_");
	if (!pDrawTextEx) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pDrawTextRect = GetProcAddress(hLib, "DrawTextRect_");
	if (!pDrawTextRect) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pTextRectCount = GetProcAddress(hLib, "TextRectCount_");
	if (!pTextRectCount) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pTextRectMaxWidth = GetProcAddress(hLib, "TextRectMaxWidth_");
	if (!pTextRectMaxWidth) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pTextRectWidth = GetProcAddress(hLib, "TextRectWidth_");
	if (!pTextRectWidth) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pStringWidthEx = GetProcAddress(hLib, "StringWidthEx_");
	if (!pStringWidthEx) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pStringHeightEx = GetProcAddress(hLib, "StringHeightEx_");
	if (!pStringHeightEx) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pGetFontProperty = GetProcAddress(hLib, "GetFontProperty_");
	if (!pGetFontProperty) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pTestRect = GetProcAddress(hLib, "TestRect_");
	if (!pTestRect) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pTestOval = GetProcAddress(hLib, "TestOval_");
	if (!pTestOval) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pTestImage = GetProcAddress(hLib, "TestImage_");
	if (!pTestImage) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pTestRendered = GetProcAddress(hLib, "TestRendered_");
	if (!pTestRendered) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pGetCustomTransform = GetProcAddress(hLib, "GetCustomTransform_");
	if (!pGetCustomTransform) { FreeLibrary(hLib); return(false); }

	(FARPROC &)pSetCustomTransform = GetProcAddress(hLib, "SetCustomTransform_");
	if (!pSetCustomTransform) { FreeLibrary(hLib); return(false); }

	return(true);
}
//---------------------------------------------------------------------
char* trim_str(char* ch) {
	int shift = 0, num = 0;
	do { if (ch[num] == ' ') { shift++; } else { ch[num-shift] = ch[num]; } } while(ch[num++]);
	return(ch);
}
//---------------------------------------------------------------------
int cFIXorsBridge::InitDraw() {
	return( pInitDraw(xGetDevice(), 0) );
}
//---------------------------------------------------------------------
int cFIXorsBridge::SetCustomBlend(int src, int dest) {
	pSetCustomState(15,0);		//	DX7  SetRenderState ( D3DRENDERSTATE_AlphaTestEnable, False )
	pSetCustomState(27,1);		//	DX7  SetRenderState ( D3DRENDERSTATE_AlphaBlendEnable, True )
	pSetCustomState(19,src);	//	DX7  SetRenderState ( D3DRENDERSTATE_SrcBlend, src )
	return pSetCustomState(20,dest);	//	DX7  SetRenderState ( D3DRENDERSTATE_DestBlend, dest )
}
//---------------------------------------------------------------------
int cFIXorsBridge::CreateImage(int texture, int width, int height, int imageFlags) {
	if (texture) {
		int Array[256];
		sFI_Surfaces surf;
		surf.Texture = texture;
		surf.Array = Array;
		surf.Count = xGetTextureFrames(texture);
		if (surf.Count>0) {
			if (surf.Count>256) surf.Count=256;
			for(register int i=0; i<surf.Count; i++) {
				surf.Array[i] = xGetTextureSurface(texture, i);
			}
			return(pCreateImageEx(&surf, width, height, imageFlags));
		}
	}
	return(0);
}
//---------------------------------------------------------------------
int cFIXorsBridge::LoadImageF(const char* fileName, int textureFlags, int imageFlags) {
	if (ImageInfo_ReadFile(fileName)) {
		return( CreateImage(xLoadTexture(fileName, textureFlags), ImgInfo.Width, ImgInfo.Height, imageFlags) );
	}
	return(0);
}
//---------------------------------------------------------------------
int cFIXorsBridge::LoadAnimImage(const char* fileName, int textureFlags, int frameWidth, int frameHeight, int firstFrame, int frameCount, int imageFlags) {
	textureFlags = (textureFlags & 0x3F) | 0x9;
	return( CreateImage( xLoadAnimTexture (fileName, textureFlags, frameWidth, frameHeight, firstFrame, frameCount), frameWidth, frameHeight, imageFlags) );
}
//---------------------------------------------------------------------
int cFIXorsBridge::TestImage(int xPoint, int yPoint, int xImage, int yImage, int Image, int alphaLevel, int Frame, int Local) {
	if (pTestImage(xPoint, yPoint, xImage, yImage, Image, Local, &Test, 1) && alphaLevel>0 && Test.Texture!=0) {
		if ( (xReadPixel(Test.TextureX, Test.TextureY, xTextureBuffer(Test.Texture,Frame))>>24)<alphaLevel ) Test.Result = 0;
	}
	return(Test.Result);
}
//---------------------------------------------------------------------
int cFIXorsBridge::TestRendered(int xPoint, int yPoint, int alphaLevel, int Local) {
	if (pTestRendered(xPoint, yPoint, Local, &Test, 1) && alphaLevel>0 && Test.Texture!=0) {
		if ( (xReadPixel(Test.TextureX, Test.TextureY, xTextureBuffer(Test.Texture,Test.Frame))>>24)<alphaLevel ) Test.Result = 0;
	}
	return(Test.Result);
}
//---------------------------------------------------------------------
void cFIXorsBridge::FreeImage(int image, int freeTexture) {
	if (freeTexture!=0 && GetImageProperty(image)!=0) {
		if (ImageProperty.Texture != 0) xFreeTexture(ImageProperty.Texture);
	}
	pFreeImageEx(image);
}
//---------------------------------------------------------------------
void cFIXorsBridge::FreeImageFont(int font) {
	if ( GetFontProperty(font) ){
		if (FontProperty.Image) FreeImage(FontProperty.Image, 1);
	}
	pFreeImageFont(font);
}
//---------------------------------------------------------------------
int cFIXorsBridge::LoadImageFont(const char* filename, int flags) {
	ifstream file(filename, ios::in | ios::binary);
	if (!file) { return(0); }

	char name[100];
	char *val;
	char *AnimTex = 0;
	int AnimTexFlag = 0;
	int num;

	//sFI_FontProperty font;

	while (file.getline(name,99)) {
		if (name[0]==59 && name[0]==13) continue;
		if ((val = strchr(name,'=')) == NULL) continue;

			*val++ = 0;
			num = strlen(val)-1;
		if (val[num] == 13) val[num] = 0;
			trim_str(name);
		trim_str(val);

			num = -1;
		while(name[++num]) { name[num] = toupper(name[num]); }

		if (strcmp(name,"ANIMTEXTURE") == 0) {
			if (AnimTex) delete AnimTex;
					num = strlen(val)+1;
			if (num > 1) {
							AnimTex = new char[num];
							strcpy_s(AnimTex,num,val);
			}
			else { AnimTex = 0; }
		}
		else if (strcmp(name,"ANIMTEXTUREFLAGS") == 0) {
			AnimTexFlag = atoi(val);
		}
		else if (strcmp(name,"FRAMEWIDTH") == 0) {
			FontProperty.FrameWidth = atoi(val);
		}
		else if (strcmp(name,"FRAMEHEIGHT") == 0) {
			FontProperty.FrameHeight = atoi(val);
		}
		else if (strcmp(name,"FRAMECOUNT") == 0) {
			FontProperty.FrameCount = atoi(val);
		}
		else if (strcmp(name,"WIDTH") == 0) {
			FontProperty.Width = atoi(val);
		}
		else if (strcmp(name,"HEIGHT") == 0) {
			FontProperty.Height = atoi(val);
		}
		else if (strcmp(name,"FIRSTCHAR") == 0) {
			FontProperty.FirstChar = atoi(val);
		}
		else if (strcmp(name,"KERNING") == 0) {
			FontProperty.Kerning = atoi(val);
		}
		else {
			num = atoi(name);
			if (-1 < num && num < 256) {
				FontProperty.Chars[num] = atoi(val);
			}
		}
	}

	file.close();
	int ImgFont = 0;

	num = strlen(AnimTex);
	if (num>0 && FontProperty.FrameWidth>0 && FontProperty.FrameHeight>0 && FontProperty.FrameCount>0) {
		const char* tmp = filename;
		const char* slash;
		char* path;
		do { slash = strchr(tmp,'/'); if (slash) tmp = slash + 1; } while(slash);
		bool clear = false;
		if (tmp != filename) {
			int len = ((int)(tmp - filename))/sizeof(char);
			path = new char[len + num + 1];
			strncpy_s(path,len+1,filename,len);
			strcat_s(path,len+num+1,AnimTex);
			clear = true;
		} else { path = AnimTex; }
		if (flags == FI_SMOOTHFONT) flags = FI_FILTEREDIMAGE;
		else flags = FI_NONE;
		FontProperty.Image = LoadImageF(path, (AnimTexFlag & 0x6) | 0x39, flags);
		ImgFont = pCreateImageFont(&FontProperty);
		if (clear) delete path;
	}

	if (AnimTex) delete AnimTex;

	return(ImgFont);
}

dieser teil macht probleme

int cFIXorsBridge::CreateImage(int texture, int width, int height, int imageFlags) {
    if (texture) {
        int Array[256];
        sFI_Surfaces surf;
        surf.Texture = texture;
        surf.Array = Array;
        surf.Count = xGetTextureFrames(texture);
        if (surf.Count>0) {
            if (surf.Count>256) surf.Count=256;
            for(register int i=0; i<surf.Count; i++) {
                surf.Array[i] = xGetTextureSurface(texture, i);
            }
            return(pCreateImageEx(&surf, width, height, imageFlags));
        }
    }
    return(0);
}

der nachbau dieser funktion in anderen sprachen geht wegen dem hier

return(pCreateImageEx(&surf, width, height, imageFlags));

nicht.warum das so ist, weiß ich nicht, rätseln so einige.
Nun ich als C++ noob, sehe oben ja auch noch mehrere includes.Die GetImageInfo dient zum laden der bilddateien.Im großen ganzen sollen bis auf die eine genannte funktion ( cFIXorsBridge::CreateImage(int texture, int width, int height, int imageFlags) ) exportiert werden, da diese nur intern noch von nutzen ist....benötigt um ein geladenes bild weiter zu verarbeiten.(edit GetCustomTransform und SetCustomTransform werden garnicht mehr benötigt)

1. ist es möglich daraus eine dll zu machen?
2. was ist mit den ganzen anderen includes? (die habe ich alle....abhängigkeiten wären somit kein problem, nur wie umsetzen)

]]>https://www.c-plusplus.net/forum/post/1691159https://www.c-plusplus.net/forum/post/1691159Sun, 05 Apr 2009 11:06:46 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 11:44:38 GMT]]>Wenn ich dich richtig verstehe möchtest Du bestehenden C++ Code in eine DLL verpacken.

Diese DLL soll dann von verschiedenen Seiten (Sprachen, Platformen, ...) genutzt werden können.

Korrekt soweit?

Simon

]]>https://www.c-plusplus.net/forum/post/1691188https://www.c-plusplus.net/forum/post/1691188Sun, 05 Apr 2009 11:44:38 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 11:48:02 GMT]]>genau, weil der code, den du meinst wiederum eine andere dll lädt(und paar dinge noch aus einer anderen mit den includes oben(/x3d/...)

aber du hast es erfasst.
eine dll für eine dll sozusagen, damit am ende zumindest eine funktion wegfällt(will später noch mehr am code ändern, aber dazu muss trotzdem erstmal eine dll her)

leider gibts wohl keine jobbörse hier, ich würd das ja auch machen lassen.brauchs halt dringend...weil ich wurschtel seit wochen mit der einbind der dll in andere sprachen, und das hier ist der letzte weg.

]]>https://www.c-plusplus.net/forum/post/1691190https://www.c-plusplus.net/forum/post/1691190Sun, 05 Apr 2009 11:48:02 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 12:24:38 GMT]]>Poste doch mal im Projekte Forum. Ev. kannst da jmd motivieren, den Job zu übernehmen.

Simon

]]>https://www.c-plusplus.net/forum/post/1691215https://www.c-plusplus.net/forum/post/1691215Sun, 05 Apr 2009 12:24:38 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 12:27:21 GMT]]>Hallo

Mal so nebenbei für welche andere Sprache brauchst du denn überhaupt die DLL weil es gibt ein paar unterschiedliche arten von Dlls.

zB du kannst die Dll als Funktionslibrary-Bauen, dann sind es einfach Funktionen die du in den anderen Sprachen hast. Oder du baust ne Com-Dll was bei weitem aufwendiger ist für die Dll, aber einfach für zB VB die Funktionen aufzurufen.

Edit: Welche Entwicklungsumgebung benutzt du?

Mfg Marco

]]>https://www.c-plusplus.net/forum/post/1691218https://www.c-plusplus.net/forum/post/1691218Sun, 05 Apr 2009 12:27:21 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 13:07:49 GMT]]>also erstmal um zu der funktion zu kommen....
in blitzbasic funktioniert es.Blitzmax im moment keine lösung gefunden, einen pointer da zu setzen auch keine chance, gibts einen memory fehler.in glbasic geht es auch nur via inline C++.

zB du kannst die Dll als Funktionslibrary-Bauen, dann sind es einfach Funktionen die du in den anderen Sprachen hast. Oder du baust ne Com-Dll was bei weitem aufwendiger ist für die Dll, aber einfach für zB VB die Funktionen aufzurufen.

wie meinst du das?
Also Funktionslibrary denke ich ist klar.Den Source umschreiben, daß die funktionen von anderen sprachen genutzt werden können.
So meinte ich das auch.
Was eine Com-Dll ist, weiß ich nun leider nicht.Aber hab mich grad schlau gemacht, eine Functionslibrary solls werden.

Und ja ich poste mal bei den Projekten, hab ich total übersehen....

Zur Entwicklungsumgebung...als C++ Beginner Visual Studio Express(hab aber grad erste Schritte gemacht, ansonsten BlitzMax, GLBasic, PureBasic und ab und an bisschen FreeBasic)

]]>https://www.c-plusplus.net/forum/post/1691236https://www.c-plusplus.net/forum/post/1691236Sun, 05 Apr 2009 13:07:49 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 13:08:09 GMT]]>Hallo

Kannst dich ja per Mail mal melden, wenn du mir dann noch sagst welche Entwicklungsumgebnung du hast kann ich dir heut abend zumindest ne Anweisung geben wie du ne Funktions-Dll erstellen kannst.

In sachzen COM, ist ne eigentheit von Microsoft. Wird hauptsächlich von VisualBasic benutzt. Weiter Infos findest du bei Google.

Mfg Marco

]]>https://www.c-plusplus.net/forum/post/1691243https://www.c-plusplus.net/forum/post/1691243Sun, 05 Apr 2009 13:08:09 GMT<![CDATA[Reply to DLL in C++ schreiben on Sun, 05 Apr 2009 13:20:49 GMT]]>Also Visual C++ 2008 Express nutze ich.
Allerdings komm ich noch nicht so perfekt zurecht da, hab erst angefangen.
Aber da ich auch nen Haufen anderer Sprachen nutze finde ich mich eigentlich in jeder Entwiclungsumgebung relativ schnell zurecht.

Mail ist soeben raus, danke dir

]]>https://www.c-plusplus.net/forum/post/1691248https://www.c-plusplus.net/forum/post/1691248Sun, 05 Apr 2009 13:20:49 GMT