DLL funktioniert nur unter C

  • C/C++

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • DLL funktioniert nur unter C

    Ich habe folgendes Problem. Ich habe eine DLL geschrieben womit man überprüfen kann ob der Mauszeiger über ein Objekt ist. Nun es funktioniert auch alles herrvoragend unter C. Mit GML gemischt habe ich eine fps von 60 bei 100 Dreiecken erzielt. Als Ich alles komplett ohne GML gemacht habe, habe ich eine unglaubliche fps von 1200 bei 10000 Dreiecken erzielt, aber leider Bugy weil C nicht richtig zwei dimensionale Arrays unterstützt.
    Es war eigentlich der Plan gleich C++ zu nehemen, aber genau da gab es Probleme. Es lässt sich zwar alles ohne Fehler Compilern und die DLL wird zwar auch erstellt und sieht auch ordentlich aus, aber im Game Maker sieht man garnichts. Nun die Frage ist, was mache ich Falsch sodass es nicht in C++ funktioniert?

    Der Header
    Spoiler anzeigen

    Quellcode

    1. #ifndef _DLL_H_
    2. #define _DLL_H_
    4. #if BUILDING_DLL
    5. # define DLLIMPORT __declspec (dllexport)
    6. #else /* Not BUILDING_DLL */
    7. # define DLLIMPORT __declspec (dllimport)
    8. #endif /* Not BUILDING_DLL */
    11. DLLIMPORT double point_in_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double xp, double yp);
    12. DLLIMPORT double convert_prepare(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, double arg7, double arg8, double arg9, double arg10, double arg11);
    13. DLLIMPORT double convert_3d(double targetx, double targety, double targetz);
    14. DLLIMPORT double convert_get_x_2d();
    15. DLLIMPORT double convert_get_y_2d();
    16. DLLIMPORT double poo_begin();
    17. DLLIMPORT double poo_vertex(double vertX, double vertY, double vertZ);
    18. DLLIMPORT double poo_end();
    19. DLLIMPORT double poo_check(double obj, double pointX, double pointY);
    21. #endif /* _DLL_H_ */
    Alles anzeigen


    Der Sourcecode
    Spoiler anzeigen

    C-Quellcode

    1. #include "dll.h"
    2. #include <windows.h>
    3. #include <stdio.h>
    4. #include <stdlib.h>
    5. #include <math.h>
    7. short sign(double arg)
    8. {
    9. if(arg < 0)
    10. return(-1);
    11. if(arg == 0)
    12. return(0);
    13. if(arg > 0)
    14. return(1);
    15. }
    17. double sqr(double arg)
    18. {
    19. return(arg*arg);
    20. }
    22. double cam_dX;
    23. double cam_dY;
    24. double cam_dZ;
    26. double cam_uX;
    27. double cam_uY;
    28. double cam_uZ;
    30. double cam_vX;
    31. double cam_vY;
    32. double cam_vZ;
    34. double cam_xfrom;
    35. double cam_yfrom;
    36. double cam_zfrom;
    38. double screen_width;
    39. double screen_height;
    41. double tFOV;
    43. double poo_vertexe_x[0][1023];
    44. double poo_vertexe_y[0][1023];
    45. double poo_vertexe_z[0][1023];
    47. int objektnumber = 0;
    49. const float pi = 3.14159f;
    51. double x_2d;
    52. double y_2d;
    54. DLLIMPORT double point_in_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double xp, double yp)
    55. {
    56. double a = (x1-xp)*(y2-yp)-(x2-xp)*(y1-yp);
    57. double b = (x2-xp)*(y3-yp)-(x3-xp)*(y2-yp);
    58. double c = (x3-xp)*(y1-yp)-(x1-xp)*(y3-yp);
    59. double back;
    61. if(sign(a) == sign(b) && sign(b) == sign(c))
    62. back = 1;
    63. else
    64. back = 0;
    66. return(back);
    67. }
    69. DLLIMPORT double convert_prepare(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, double arg7, double arg8, double arg9, double arg10, double arg11)
    70. {
    71. double mm;
    73. cam_dX = arg3 - arg0;
    74. cam_dY = arg4 - arg1;
    75. cam_dZ = arg5 - arg2;
    76. mm = sqrt(cam_dX*cam_dX + cam_dY*cam_dY + cam_dZ*cam_dZ);
    77. cam_dX /= mm;
    78. cam_dY /= mm;
    79. cam_dZ /= mm;
    80. cam_uX = arg6;
    81. cam_uY = arg7;
    82. cam_uZ = arg8;
    83. mm = cam_uX*cam_dX + cam_uY*cam_dY + cam_uZ*cam_dZ;
    84. cam_uX -= mm*cam_dX;
    85. cam_uY -= mm*cam_dY;
    86. cam_uZ -= mm*cam_dZ;
    87. mm = sqrt(cam_uX*cam_uX + cam_uY*cam_uY + cam_uZ*cam_uZ);
    88. cam_uX /= mm;
    89. cam_uY /= mm;
    90. cam_uZ /= mm;
    91. tFOV = tan(arg9*pi/360);
    92. cam_uX *= tFOV;
    93. cam_uY *= tFOV;
    94. cam_uZ *= tFOV;
    95. cam_vX = cam_uY*cam_dZ - cam_dY*cam_uZ;
    96. cam_vY = cam_uZ*cam_dX - cam_dZ*cam_uX;
    97. cam_vZ = cam_uX*cam_dY - cam_dX*cam_uY;
    98. cam_vX *= arg10/arg11;
    99. cam_vY *= arg10/arg11;
    100. cam_vZ *= arg10/arg11;
    101. cam_xfrom = arg0;
    102. cam_yfrom = arg1;
    103. cam_zfrom = arg2;
    104. screen_width = arg10;
    105. screen_height = arg11;
    107. return(1);
    108. }
    110. DLLIMPORT double convert_3d(double targetx, double targety, double targetz)
    111. {
    112. double pX;
    113. double pY;
    114. double pZ;
    115. double mm;
    117. pX = targetx - cam_xfrom;
    118. pY = targety - cam_yfrom;
    119. pZ = targetz - cam_zfrom;
    120. mm = pX*cam_dX + pY*cam_dY + pZ*cam_dZ;
    122. if (mm > 0)
    123. {
    124. pX /= mm;
    125. pY /= mm;
    126. pZ /= mm;
    127. }
    128. else
    129. {
    130. x_2d = 0;
    131. y_2d = -100;
    132. return (0);
    133. }
    138. mm = (pX*cam_vX + pY*cam_vY + pZ*cam_vZ) / sqr((screen_width/screen_height)*tan(45*pi/360));
    139. x_2d = (mm+1)/2*screen_width;
    140. mm = (pX*cam_uX + pY*cam_uY + pZ*cam_uZ) / sqr(tan(45*pi/360));
    141. y_2d = (1-mm)/2*screen_height;
    142. return(1);
    143. }
    145. DLLIMPORT double convert_get_x_2d()
    146. {
    147. return(x_2d);
    148. }
    150. DLLIMPORT double convert_get_y_2d()
    151. {
    152. return(y_2d);
    153. }
    155. DLLIMPORT double poo_begin()
    156. {
    157. poo_vertexe_x[objektnumber][0] = 1;
    158. poo_vertexe_y[objektnumber][0] = 1;
    159. poo_vertexe_z[objektnumber][0] = 1;
    161. return(1);
    162. }
    164. DLLIMPORT double poo_vertex(double vertX, double vertY, double vertZ)
    165. {
    166. poo_vertexe_x[objektnumber][(int)poo_vertexe_x[objektnumber][0]] = vertX;
    167. poo_vertexe_y[objektnumber][(int)poo_vertexe_x[objektnumber][0]] = vertY;
    168. poo_vertexe_z[objektnumber][(int)poo_vertexe_x[objektnumber][0]] = vertZ;
    170. poo_vertexe_x[objektnumber][0] += 1;
    171. poo_vertexe_y[objektnumber][0] += 1;
    172. poo_vertexe_z[objektnumber][0] += 1;
    173. return(1);
    174. }
    176. DLLIMPORT double poo_end()
    177. {
    178. objektnumber += 1;
    179. return(objektnumber - 1);
    180. }
    182. DLLIMPORT double poo_check(double obj, double pointX, double pointY)
    183. {
    184. double back = 0;
    185. int objekt;
    186. double px1;
    187. double py1;
    189. double px2;
    190. double py2;
    192. double px3;
    193. double py3;
    195. objekt = (int)obj;
    197. int i;
    199. for(i=1; i<poo_vertexe_x[objekt][0]; i+=3)
    200. {
    203. convert_3d(poo_vertexe_x[objekt][i],poo_vertexe_y[objekt][i],poo_vertexe_z[objekt][i]);
    204. px1 = x_2d;
    205. py1 = y_2d;
    207. convert_3d(poo_vertexe_x[objekt][i+1],poo_vertexe_y[objekt][i+1],poo_vertexe_z[objekt][i+1]);
    208. px2 = x_2d;
    209. py2 = y_2d;
    211. convert_3d(poo_vertexe_x[objekt][i+2],poo_vertexe_y[objekt][i+2],poo_vertexe_z[objekt][i+2]);
    212. px3 = x_2d;
    213. py3 = y_2d;
    215. if(point_in_triangle(px1,py1,px2,py2,px3,py3,pointX,pointY))
    216. {
    217. back = 1;
    218. break;
    219. }
    220. }
    221. return(back);
    222. }
    226. BOOL APIENTRY DllMain (HINSTANCE hInst /* Library instance handle. */ ,
    227. DWORD reason /* Reason this function is being called. */ ,
    228. LPVOID reserved /* Not used. */ )
    229. {
    230. switch (reason)
    231. {
    232. case DLL_PROCESS_ATTACH:
    233. break;
    235. case DLL_PROCESS_DETACH:
    236. break;
    238. case DLL_THREAD_ATTACH:
    239. break;
    241. case DLL_THREAD_DETACH:
    242. break;
    243. }
    245. /* Returns TRUE on success, FALSE on failure */
    246. return TRUE;
    247. }
    Alles anzeigen

  • Mit diesem Thema (wenn ich auch für einen anderen Bereich) habe ich mich vor kurzem erst beschäftig.

    Was mich wundert ist, dass wie du darauf kommst einfach den Code von C für ++ und Game Maker zu übernehmen.
    Der Unterschied ist doch ganz klar, dass der Game Maker und C++ Objektorientiert arbeiten (klassen etc), C jedoch nicht.

    der Code ist zwar portierbar, aber sowas wie int, char und co wirst du im Gamemaker vergeblich suchen.
    bei C++ kenne ich mich zwar nicht genügend aus, um dazu ein Statement abzugeben, jedoch (auch wenn es eine erweiterung ist) hat es einen anderen Standart als der von C.
    so kann es zwar durchaus sein, dass die Syntax richtig ist (würde mich auch wundern, wenn sie das nicht würde) aber letztendlich volkommener Käse rauskommt.

  • Mit welcher Entwicklungsumgebung hast du das denn kompiliert? MS VS, Netbeans, Eclipse, etc.?
    Schau mal nach, ob du es genau so machst, wie es in diesem Tutorial beschrieben ist.
    In deinem Header sieht die Präprozessoranweisung für das Exportieren der Dll etwas anders aus als in dem Tutorial.

    Quellcode

    1. #define GMEXPORT extern "C" __declspec (dllexport)

    Albert Einstein schrieb:

    Probleme kann man niemals mit derselben Denkweise lösen, durch die sie entstanden sind.

  • Ich habe etwas seltsames herausgefunden. Ich habe es mit extern "C" versucht und jetzt sagt der Game Maker das ich eine Zugriffsverletzung auf einer Speicheradresse mache wenn ich die Funktion poo_vertex aufrufe. Wenn ich die Funktion nicht aufrufe und es wie vorher mit GML mische funktioniert alles wieder. Dann habe ich herausgefunden dass einfach der Speicherplatz im Array nicht reserviert habe bei

    Quellcode

    1. double poo_vertexe_x[0][1023];
    2. double poo_vertexe_y[0][1023];
    3. double poo_vertexe_z[0][1023];

    habe ich geändert in

    Quellcode

    1. double poo_vertexe_x[1023][1023];
    2. double poo_vertexe_y[1023][1023];
    3. double poo_vertexe_z[1023][1023];


    Nun zeigt er keine Zugriffsverletzung mehr an, aber es geschieht jetzt genauso wie vorher nichts, und selbst wenn ich es mit GML mische obwohl es nichts miteinander zutun hat, passiert nichts. Es findet keine Kollision statt, zwischen Maus und Objekt. In C war es wenigstens so, dass wenn man irgendwo in die Leere zeigt eine Kollision auftritt. Das ist alles sehr seltsam.

  • Benutzer online 1

    1 Besucher