API tools faq
paste
Advertisement
DVS_studio

Engine.h

DVS_studio
Nov 21st, 2017
131
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.88 KB | None | 0 0
raw download clone embed print report
  1. #pragma once
  2.  
  3. #ifdef DVSENGINE_EXPORTS
  4. #define DVSENGINE_API __declspec(dllexport)
  5. #else
  6. #define DVSENGINE_API __declspec(dllimport)
  7. #pragma comment(lib,"DVSEngine.lib")
  8. #endif
  9.  
  10. #define _USE_MATH_DEFINES
  11. #define _CRT_SECURE_NO_WARNINGS
  12. #define _CRT_NON_CONFORMING_WCSTOK
  13. #define _CRT_NON_CONFORMING_SWPRINTFS
  14.  
  15. #pragma comment(lib,"winmm.lib")
  16. #pragma comment(lib,"ftgl_dynamic_MT.lib")
  17. #pragma comment(lib,"DevIL.lib")
  18. #pragma comment(lib,"ILUT.lib")
  19. #pragma comment(lib,"ILU.lib")
  20. #pragma comment(lib,"freetype.lib")
  21. #pragma comment(lib,"Shlwapi.lib")
  22.  
  23.  
  24. #include <windows.h>
  25. #include <gl/freeglut.h>
  26. #include <cmath>
  27. #include <cwchar>
  28. #include <string>
  29. #include <vector>
  30. #include <map>
  31. #include <memory>
  32.  
  33. #include <Shlwapi.h>
  34. #include <io.h>
  35.  
  36. #include <il/ilu.h>
  37. #include <ftgl/FTFont.h>
  38. #include <ftgl/FTGLBitmapFont.h>
  39. #include <ftgl/FTGLOutlineFont.h>
  40.  
  41. using namespace std;
  42.  
  43. typedef unsigned char byte;
  44.  
  45. #define V4toxyzw(t) t.x, t.y, t.z, t.w
  46. #define V4toxyz(t) t.x, t.y, t.z
  47. #define V4toxy(t) t.x, t.y
  48.  
  49. #define max3(a,b,c) (max(a,max(b,c)))
  50. #define min3(a,b,c) (min(a,min(b,c)))
  51.  
  52. #define FONT_DIR "Resources/Fonts/%s"
  53. #define MODEL_DIR "Resources/Models/%s"
  54. #define RESOURCE_DIR "Resources"
  55.  
  56. #define DIV_TYPE_AABB 0
  57. #define DIV_TYPE_SPHERE 1
  58.  
  59. namespace DVSEngine {
  60.     class V3 {
  61.     public:
  62.         DVSENGINE_API V3() { x = y = z = 0.0f; }
  63.         DVSENGINE_API V3(float X, float Y) { x = X; y = Y; }
  64.         DVSENGINE_API V3(float X, float Y, float Z) { x = X; y = Y; z = Z; }
  65.  
  66.         float x, y, z;
  67.     };
  68.  
  69.     class V4 {
  70.     public:
  71.         DVSENGINE_API V4();
  72.         DVSENGINE_API V4(float X, float Y);
  73.         DVSENGINE_API V4(int X, int Y);
  74.         DVSENGINE_API V4(float X, float Y, float Z);
  75.         DVSENGINE_API V4(int X, int Y, int Z);
  76.         DVSENGINE_API V4(float X, float Y, float Z, float W);
  77.         DVSENGINE_API V4(const V3 &v);
  78.         DVSENGINE_API V4(const V4 &v);
  79.         DVSENGINE_API V4(const POINT &v);
  80.  
  81.         DVSENGINE_API operator V3();
  82.         DVSENGINE_API operator float*();
  83.  
  84.         DVSENGINE_API void operator=(V4 v);                        // ������������� �������� =
  85.  
  86.         DVSENGINE_API V4 operator-();
  87.  
  88.         DVSENGINE_API V4 operator-(V4 v);                    // ������������� �������� -
  89.         DVSENGINE_API V4 operator+(V4 v);                    // ������������� �������� +
  90.         DVSENGINE_API V4 operator*(V4 v);                    // ������������� �������� *
  91.         DVSENGINE_API V4 operator/(V4 v);                    // ������������� �������� /
  92.  
  93.         DVSENGINE_API V4 operator+(float f);                       // ������������� �������� +
  94.         DVSENGINE_API V4 operator-(float f);                       // ������������� �������� -
  95.         DVSENGINE_API V4 operator*(float f);                       // ������������� �������� *
  96.         DVSENGINE_API V4 operator/(float f);                       // ������������� �������� /
  97.  
  98.         DVSENGINE_API void operator +=(V4 v);                      // ������������� �������� +=
  99.         DVSENGINE_API void operator -=(V4 v);                      // ������������� �������� -=
  100.         DVSENGINE_API void operator *=(V4 v);                      // ������������� �������� *=
  101.         DVSENGINE_API void operator /=(V4 v);                      // ������������� �������� /=
  102.  
  103.         DVSENGINE_API void operator +=(float f);                         // ������������� �������� +=
  104.         DVSENGINE_API void operator -=(float f);                         // ������������� �������� -=
  105.         DVSENGINE_API void operator *=(float f);                         // ������������� �������� *=
  106.         DVSENGINE_API void operator /=(float f);                         // ������������� �������� /=
  107.  
  108.         DVSENGINE_API bool operator ==(V4 v);                      // ������������� �������� ==
  109.         DVSENGINE_API bool operator !=(V4 v);                      // ������������� �������� !=
  110.  
  111.         DVSENGINE_API V4 Cross(V4 v1, V4 v2);              // ���������� Cross Product �������� v1 � v2.
  112.         DVSENGINE_API V4 Cross(V4 v1, V4 v2, V4 v3);                   // ���������� Cross Product �������� v1, v2, V4.
  113.  
  114.         DVSENGINE_API float DotProduct3(V4 v1);                    // ��������� ������������ 3 �� v1
  115.         DVSENGINE_API float DotProduct4(V4 v1);                    // ��������� ������������ 4 �� v1
  116.  
  117.         DVSENGINE_API float GetLength();                                 // ���������� ������ ������� �������
  118.         DVSENGINE_API V4 Normal();                                     // ����������� ������
  119.         DVSENGINE_API void Normalize(V4 Triangle[]);               // ������� ������� ������������
  120.  
  121.         DVSENGINE_API V4 GetRotatedX(float angle);
  122.         DVSENGINE_API V4 GetRotatedY(float angle);
  123.         DVSENGINE_API V4 GetRotatedZ(float angle);
  124.         DVSENGINE_API V4 GetRotatedAxis(float angle, V4 axis);
  125.  
  126.         DVSENGINE_API void maxXYZ(V4 v);
  127.         DVSENGINE_API void minXYZ(V4 v);
  128.         DVSENGINE_API void set(float f);
  129.  
  130.         float x, y, z, w;
  131.     };
  132.  
  133.     struct SPHERE {
  134.         V4 position;
  135.         float radius;
  136.     };
  137.  
  138.     struct BOX {
  139.         V4 minV, maxV;
  140.     };
  141.  
  142.     struct RAY {
  143.         V4 begin, end;
  144.     };
  145.  
  146.     struct PLANE {
  147.         V4 p1, p2, p3, normal;
  148.     };
  149.  
  150.     struct Div {
  151.         operator SPHERE() {
  152.             return SPHERE{ { V4toxyz(v1) }, v1.w };
  153.         }
  154.         operator BOX() {
  155.             return BOX{ { V4toxyz(v1) },{ V4toxyz(v2) } };
  156.         }
  157.         operator RAY() {
  158.             return RAY{ { V4toxyz(v1) },{ V4toxyz(v2) } };
  159.         }
  160.         V4 v1, v2;
  161.     };
  162.  
  163.     struct PolygonS {
  164.         V4 p1, p2, p3;
  165.         V4 normal;
  166.         char *texture;
  167.         V4 tp1, tp2, tp3;
  168.     };
  169.  
  170.     struct DebugS {
  171.         bool showModel = true;
  172.         bool showDiv = false;
  173.         bool showNormal = false;
  174.         bool noclip = false;
  175.         bool fly = false;
  176.     };
  177.  
  178.     enum FrustumSide {
  179.         RIGHT = 0,        // ������ ������� ��������
  180.         LEFT = 1,        // ����� ������� ��������
  181.         BOTTOM = 2,        // ������ ������� ��������
  182.         TOP = 3,        // ������� ������� ��������
  183.         BACK = 4,        // ������ ������� ��������
  184.         FRONT = 5         // ��������
  185.     };
  186.  
  187.     class Quaternion {
  188.     public:
  189.         DVSENGINE_API Quaternion();
  190.         DVSENGINE_API Quaternion(V4 v);
  191.         DVSENGINE_API Quaternion(V4 v, float degrees, bool is_radian = true);
  192.         DVSENGINE_API void Quaternion::CreateFromAxisAngle(V4 v, float degrees);
  193.         DVSENGINE_API void Quaternion::CreateFromAxisRadian(V4 v, float angle);
  194.  
  195.         DVSENGINE_API Quaternion *Quaternion::mul(Quaternion*);
  196.         DVSENGINE_API Quaternion *Quaternion::sum(Quaternion*);
  197.         DVSENGINE_API Quaternion *Quaternion::Inverse();
  198.         DVSENGINE_API float Quaternion::QMagnitude();
  199.  
  200.         DVSENGINE_API Quaternion rotate(Quaternion q);
  201.         DVSENGINE_API Quaternion rotate(V4 q);
  202.  
  203.         static DVSENGINE_API Quaternion rotate(Quaternion *q, Quaternion *p);
  204.         static DVSENGINE_API Quaternion rotate(V4 qv, Quaternion *p);
  205.         static DVSENGINE_API Quaternion rotate(Quaternion *q, V4 v, float a, bool i = true);
  206.         static DVSENGINE_API Quaternion rotate(V4 qv, V4 pv, float a, bool i = true);
  207.  
  208.         DVSENGINE_API operator V4();
  209.         V4 v;
  210.     };
  211.  
  212.     class Frustum {
  213.     public:
  214.         DVSENGINE_API void CalculateFrustum();
  215.         DVSENGINE_API bool PointInFrustum(V4 p);
  216.         DVSENGINE_API bool SphereInFrustum(V4 p, float radius);
  217.         DVSENGINE_API bool CubeInFrustum(V4 p, float size);
  218.     private:
  219.         V4 m_Frustum[6];
  220.     };
  221.  
  222.     class CFont {
  223.     public:
  224.         DVSENGINE_API CFont(char *ttf, int FSize, float FDepth);
  225.         FTGLBitmapFont *Font;
  226.         DVSENGINE_API void Print(V4 p, V4 c, wstring text);
  227.         DVSENGINE_API void Printf(V4 p, V4 c, wstring fmt, ...);
  228.     };
  229.  
  230.     class Console {
  231.     public:
  232.         DVSENGINE_API Console();
  233.  
  234.         DVSENGINE_API void toggle();
  235.         DVSENGINE_API void draw();
  236.         DVSENGINE_API void print(wstring s);
  237.         DVSENGINE_API void println(wstring string);
  238.         DVSENGINE_API void parseln(wstring string);
  239.  
  240.         DVSENGINE_API Console operator << (wstring string);
  241.  
  242.         bool is_open = false;
  243.         wstring stack[10];
  244.         bool newLine = false;
  245.         std::map <wstring, void(*)()> funcs;
  246.  
  247.         vector<wstring> param;
  248.     };
  249.  
  250.     class Camera {
  251.     public:
  252.         DVSENGINE_API Camera();
  253.         DVSENGINE_API void Look();
  254.         DVSENGINE_API void FirstPersonView(int mx, int my);
  255.         DVSENGINE_API void ThirdPersonView();
  256.         DVSENGINE_API void setPosition(V4 position);
  257.         DVSENGINE_API void setViewTo(V4 viewTo);
  258.         DVSENGINE_API void lockView();
  259.         DVSENGINE_API void unlockView();
  260.  
  261.         V4 Position, LookPos;
  262.         V4 View;
  263.         V4 Up;
  264.         V4 Strafe;
  265.         bool locked, needMouseZoom;
  266.         float Sensitivity;
  267.         float Zoom, ZoomLimit;
  268.     };
  269.  
  270. #ifndef DVSENGINE_UNUSE_MODEL
  271.     class Model {
  272.     public:
  273.  
  274.         struct ModelPart {
  275.             char name[40];
  276.             unsigned int listId;
  277.             vector<PolygonS> polygons;
  278.             unsigned short divType;
  279.             Div div;
  280.             bool is_static;
  281.         };
  282.  
  283.         DVSENGINE_API Model(char *modelfile, V4 color = V4{ 1.0f,1.0f,1.0f });
  284.         DVSENGINE_API void loadModel(char *modelfile);
  285.         DVSENGINE_API void calculateDiv();
  286.         DVSENGINE_API void drawPart(ModelPart *mpart);
  287.         DVSENGINE_API void buildPart(ModelPart *mpart);
  288.         DVSENGINE_API void drawModel(V4 position);
  289.  
  290.         unsigned short divType;
  291.         Div div;
  292.  
  293.         vector<ModelPart> parts;
  294.  
  295.         V4 color;
  296.     };
  297. #endif
  298. #ifndef DVSENGINE_UNUSE_OBJECT
  299.     class Object {
  300.     public:
  301.         DVSENGINE_API Object(float _mass, V4 _pos, char *modelfile);
  302.         DVSENGINE_API void setPreTickFunc(void f());
  303.         DVSENGINE_API void setPreDrawFunc(void f());
  304.         DVSENGINE_API void tick(float dt);
  305.         DVSENGINE_API void tick();
  306.         DVSENGINE_API void draw();
  307.  
  308.         DVSENGINE_API void applyVelocity(V4 _velocity);
  309.         DVSENGINE_API void applyForce(V4 _force);
  310.         DVSENGINE_API void applyGravity();
  311.         DVSENGINE_API void applyFriction();
  312.         void(*preTick)(), (*preDraw)();
  313.         bool is_static;
  314.  
  315. #ifndef DVSENGINE_UNUSE_OBJECT
  316.         Model *model;
  317. #endif
  318.         float mass;
  319.         V4 moving;
  320.         V4 position;
  321.         V4 velocity;
  322.         V4 force;
  323.     };
  324. #endif
  325. #ifndef DVSENGINE_UNUSE_PHYSICS
  326.     class Physics {
  327.     public:
  328.         DVSENGINE_API Physics();
  329.         DVSENGINE_API Physics(float g);
  330.         DVSENGINE_API bool getIntersection(Object o1, Object o2);
  331.         float g;
  332.     };
  333. #endif
  334.  
  335. #pragma region ����������
  336.  
  337. #pragma region ������ �������������� �������
  338.     DVSENGINE_API short sign(int a);
  339.     // ���� ��������� ����� �������
  340.     DVSENGINE_API float Distance(V4 vPoint1, V4 vPoint2);
  341.     // ���� ��������� �� ����� �� ���������
  342.     DVSENGINE_API float PlaneDistance(V4 Normal, V4 Point);
  343.     // ���� ��������� ����� �� �����
  344.     DVSENGINE_API V4 ClosestPointOnLine(V4 vA, V4 vB, V4 vPoint);
  345.     // ���� ��������� ����� �� ���������
  346.     DVSENGINE_API V4 ClosestPointOnPlane(PolygonS p, V4 vPoint);
  347.     // ��������� ���� ����� ���������
  348.     DVSENGINE_API float AngleBetweenVectors(V4 Vector1, V4 Vector2);
  349.     // ���������� ������ ����� ����� � ������ �������
  350.     DVSENGINE_API V4 getBezierPoint(vector<V4> pts, float t);
  351. #pragma endregion
  352.  
  353. #pragma region ������� ��� ��������
  354.     // ����������, ����� �� ����� ������ ������������
  355.     DVSENGINE_API bool InsidePolygon(V4 vIntersection, PLANE poly);
  356.     // ����������, ���������� �� ����� ��������� � ����������
  357.     DVSENGINE_API bool ClassifySphere(SPHERE Sph, PLANE poly, float &distance);
  358.     // ����������, ���������� �� ����� ��������� � ����������
  359.     DVSENGINE_API bool ClassifyPoint(V4 TestV, PLANE poly, float &distance);
  360.  
  361.     DVSENGINE_API float SquaredDistPointAABB(V4 pointV, BOX aabb);
  362.     // ����������, ���������� �� ����� �����-���� ����� ������������
  363.     DVSENGINE_API bool LineSphereCollision(V4 linep1, V4 linep2, SPHERE Sph);
  364.     // ����������, ���������� �� ����� �����-���� ����� ������������
  365.     DVSENGINE_API bool EdgeSphereCollision(SPHERE Sph, PLANE Pla);
  366.     // ���������� ����� �� ����� � AABB
  367.     DVSENGINE_API bool PointInAABB(V4 PointV, BOX tBox);
  368. #pragma endregion
  369.  
  370. #pragma endregion
  371.  
  372. #pragma region �����
  373.     char **CommandLineToArgvA(PCHAR CmdLine, int* _argc);
  374.     wchar_t keyboardRuToEng(wchar_t c);
  375.     DVSENGINE_API void split(wstring &s, const wchar_t* delim, vector<wstring> & v);
  376.     DVSENGINE_API wstring format(wstring fmt_str, ...);
  377. #pragma endregion
  378.  
  379. #pragma region �������
  380.  
  381.     DVSENGINE_API void to2D();
  382.     DVSENGINE_API void backTo3D();
  383.     DVSENGINE_API void CalculateFrameRate();
  384.     DVSENGINE_API void draw2DTexturedSquare(V4 p1, V4 p2, V4 c, V4 tp1 = V4(), V4 tp2 = V4());
  385.     DVSENGINE_API GLuint LoadTexture(string dir, string F);
  386.     DVSENGINE_API GLuint LoadTexture(string F);
  387.  
  388. #pragma endregion
  389.  
  390. #pragma region ������
  391.     DVSENGINE_API void exitA();
  392.     DVSENGINE_API void toggle();
  393.     DVSENGINE_API void setFPS();
  394. #pragma endregion
  395.  
  396. #pragma region MAIN
  397.     class MAIN;
  398.     class MAINDestructor {
  399.     private:
  400.         MAIN *p_instance;
  401.     public:
  402.         ~MAINDestructor();
  403.         DVSENGINE_API void initialize(MAIN* p);
  404.     };
  405.  
  406.     class MAIN {
  407.     private:
  408.         static MAIN* p_instance;
  409.         static MAINDestructor destroyer;
  410.     protected:
  411.         ~MAIN() {}
  412.         friend class MAINDestructor;
  413.         friend void IdleF();
  414.         friend void IdleF(int v) { IdleF(); }
  415.         friend void DisplayF();
  416.         friend void DisplayF(int v) { glutPostRedisplay(); }
  417.         friend void ReshapeF(int width, int height);
  418.         friend void MouseF(int button, int state, int x, int y);
  419.         friend void ActionMouseF(int x, int y);
  420.         friend void PassiveMouseF(int x, int y);
  421.         friend void KeyPressF(byte ch, int x, int y);
  422.         friend void KeyReleaseF(byte ch, int x, int y);
  423.         friend void KeySpecPressF(int ch, int x, int y);
  424.         friend void KeySpecReleaseF(int ch, int x, int y);
  425.     public:
  426.         static DVSENGINE_API MAIN *getInstance();
  427.         DVSENGINE_API void setWindow(int *argcp, char **argv);
  428.         DVSENGINE_API char **setWindow(char *exeName, LPSTR cmdLine, int *argc);
  429.         DVSENGINE_API void createWindow(char *title, V4 bounds);
  430.         DVSENGINE_API void setDIFunc(void _I(), void _D3d(), void _D2d()) { I = _I, D3d = _D3d, D2d = _D2d; }
  431.         DVSENGINE_API void setMFuncs(void _M(int button, int state, int x, int y), void _Ma(int x, int y), void _Mp(int x, int y)) { M = _M, Ma = _Ma, Mp = _Mp; }
  432.         DVSENGINE_API void setKFuncs(void _Kp(byte ch, int x, int y), void _Kr(byte ch, int x, int y)) { Kp = _Kp, Kr = _Kr; }
  433.         DVSENGINE_API void setKsFuncs(void _Ksp(int ch, int x, int y), void _Ksr(int ch, int x, int y)) { Ksp = _Ksp, Ksr = _Ksr; }
  434.         DVSENGINE_API void Init(void In());
  435.         DVSENGINE_API void Start();
  436.  
  437. #pragma region ���. �������
  438.  
  439.         DVSENGINE_API void pointerToCenter(bool visibleCursor);
  440.         DVSENGINE_API void setMaxFPS(int maxFPS);
  441. #pragma endregion
  442. #pragma region GLUT �������
  443.         void(*I)(), (*D3d)(), (*D2d)();
  444.         void(*M)(int, int, int, int), (*Ma)(int, int), (*Mp)(int, int);
  445.         void(*Kp)(byte, int, int), (*Kr)(byte, int, int);
  446.         void(*Ksp)(int, int, int), (*Ksr)(int, int, int);
  447. #pragma endregion
  448.  
  449.         int Width, Height;
  450.         int FPS, FPSlimit, ThoudevFps;
  451.         float dT;
  452.         POINT mouse;
  453.         bool Pause;
  454.         wstring tmpStr;
  455.         CFont *arial_16;
  456.         float time;
  457.  
  458.         bool kbd[256];
  459.         bool is_alt = false;
  460.         bool is_ctrl = false;
  461.         bool is_shift = false;
  462.  
  463.         DebugS debug;
  464.         Console cout;
  465.         Camera *camera;
  466.         map<string, GLuint> textures;
  467.  
  468. #ifndef DVSENGINE_UNUSE_PHYSICS
  469.         Physics *physics;
  470. #endif
  471. #ifndef DVSENGINE_UNUSE_OBJECT
  472.         vector<Object *> objs;
  473. #endif
  474.  
  475.     };
  476.  
  477. #pragma endregion
  478.  
  479.     extern MAIN *MC;
  480.  
  481. };
  482.  
  483.  
  484. #ifndef DVSENGINE_EXPORTS
  485. using namespace DVSEngine;
  486. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!