diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..796b96d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/build diff --git a/engine/gen_vs2022.bat b/engine/gen_vs2022.bat new file mode 100644 index 0000000..26ac53e --- /dev/null +++ b/engine/gen_vs2022.bat @@ -0,0 +1 @@ +..\tools\premake5.exe vs2022 \ No newline at end of file diff --git a/engine/main.cpp b/engine/main.cpp index 9f684da..4092327 100644 --- a/engine/main.cpp +++ b/engine/main.cpp @@ -4,18 +4,24 @@ #include "filesystem/filemanager.h" #include "render/render.h" +#include "utils/logger.h" +#include "server/entity.h" int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int iCmdShow) { + LogMsg("Unease OpenGL video driver. Build 0.01 " __DATE__); + // Initialize file manager g_fileManager = new FileManager(); // Start renderer R_Init(); + TestRTTI(); + MSG msg; while(GetMessage(&msg, NULL, 0, 0)) { diff --git a/engine/premake5.lua b/engine/premake5.lua new file mode 100644 index 0000000..3136135 --- /dev/null +++ b/engine/premake5.lua @@ -0,0 +1,76 @@ +solution "game" + configurations { + "Debug", + "Release" + } + + platforms { + "x32", + "x64", + } + + language "C++" + location "../build" + targetdir "../build/bin" + characterset "MBCS" + rtti "Off" + + filter "x64" + targetdir "bin_x64" + + filter "windows" + defines { "_WIN32", "WIN32", "WINDOWS" } + + filter "Debug" + defines { "DEBUG", "_DEBUG" } + targetsuffix "_d" + flags { "Symbols" } + + filter "Release" + defines { "NDEBUG" } + flags { "Symbols", "OptimizeSpeed", "No64BitChecks" } + + --filter {} + + +PROJ_DIR = path.getabsolute(".") +LIB_DIR = path.getabsolute("../sdk") + +-- Engine +project "engine" + kind "WindowedApp" + filter "x32" + targetname "enginex86" + filter "x64" + targetname "enginex64" + filter {} + + includedirs { + PROJ_DIR, + LIB_DIR, + } + + files { + ----------------------------------------- + -- Engine + path.join(PROJ_DIR, "*.cpp"), + path.join(PROJ_DIR, "*.h"), + + path.join(PROJ_DIR, "utils/*.cpp"), + path.join(PROJ_DIR, "utils/*.h"), + + path.join(PROJ_DIR, "filesystem/*.cpp"), + path.join(PROJ_DIR, "filesystem/*.h"), + + path.join(PROJ_DIR, "input/*.cpp"), + path.join(PROJ_DIR, "input/*.h"), + + path.join(PROJ_DIR, "render/*.cpp"), + path.join(PROJ_DIR, "render/*.h"), + + path.join(PROJ_DIR, "server/*.cpp"), + path.join(PROJ_DIR, "server/*.h"), + + } + + links { "opengl32" } diff --git a/engine/render/gl_shared.cpp b/engine/render/gl_shared.cpp index bb64643..97cf9e1 100644 --- a/engine/render/gl_shared.cpp +++ b/engine/render/gl_shared.cpp @@ -1,6 +1,10 @@ #include "utils/logger.h" #include "render/gl_shared.h" #include "render/render_shared.h" +#include "render/render.h" + +HDC hDC = NULL; +HGLRC hRC = NULL; const char *GL_ErrorString( int err ) { @@ -27,21 +31,21 @@ void GL_CheckError() { GLenum err; if ( (err = glGetError()) != GL_NO_ERROR ) - Msg( "OpenGL Error: %s", GL_ErrorString( err ) );// Msg("OpenGL Error: %s [%s]\n", GL_ErrorString(err), GL_TargetToString(tex->target)); + LogMsg( "OpenGL Error: %s", GL_ErrorString( err ) );// Msg("OpenGL Error: %s [%s]\n", GL_ErrorString(err), GL_TargetToString(tex->target)); } void GL_CheckErrorEx( const char* filename, int line ) { GLenum err; if ( (err = glGetError()) != GL_NO_ERROR ) - Msg( "OpenGL Error: %s at %s:%i", GL_ErrorString( err ), filename, line );// Msg("OpenGL Error: %s [%s]\n", GL_ErrorString(err), GL_TargetToString(tex->target)); + LogMsg( "OpenGL Error: %s at %s:%i", GL_ErrorString( err ), filename, line );// Msg("OpenGL Error: %s [%s]\n", GL_ErrorString(err), GL_TargetToString(tex->target)); } void GL_CheckErrorFunction(const char* expression, const char* filename, int line) { GLenum err; if ( (err = glGetError()) != GL_NO_ERROR ) - Msg( "OpenGL Error: %s (%s) at %s:%i", expression, GL_ErrorString( err ), filename, line );// Msg("OpenGL Error: %s [%s]\n", GL_ErrorString(err), GL_TargetToString(tex->target)); + LogMsg( "OpenGL Error: %s (%s) at %s:%i", expression, GL_ErrorString( err ), filename, line );// Msg("OpenGL Error: %s [%s]\n", GL_ErrorString(err), GL_TargetToString(tex->target)); } void GL_SetTexture( int slot, uint texture ) @@ -87,6 +91,86 @@ uint GetGLBlendFactor(BlendFactor factor) return 0; } +GLint GetGlWrap(TextureWrap wrap) +{ + GLint param = 0; + + if (wrap == TW_REPEAT) + param = GL_REPEAT; + else if (wrap == TW_MIRRORED_REPEAT) + param = GL_MIRRORED_REPEAT; + else if (wrap == TW_CLAMP_TO_EDGE) + param = GL_CLAMP_TO_EDGE; + else if (wrap == TW_CLAMP_TO_BORDER) + param = GL_CLAMP_TO_BORDER; + + return param; +} + +GLint GetGlTexFilter(TextureFilter filter) +{ + GLint param = 0; + + if (filter == TF_LINEAR) + param = GL_LINEAR; + else if (filter == TF_NEAREST) + param = GL_NEAREST; + else if (filter == TF_LINEAR_MIPMAP_LINEAR) + param = GL_LINEAR_MIPMAP_LINEAR; + else if (filter == TF_LINEAR_MIPMAP_NEAREST) + param = GL_LINEAR_MIPMAP_NEAREST; + else if (filter == TF_NEAREST_MIPMAP_LINEAR) + param = GL_NEAREST_MIPMAP_LINEAR; + else if (filter == TF_NEAREST_MIPMAP_NEAREST) + param = GL_NEAREST_MIPMAP_NEAREST; + + return param; +} + +uint GetGLPF(PixelFormat pf) +{ + return 0; + //return uint32_t(); +} + +// Kirill: Remove to render_main.cpp or something else +uint GetGLInternalPF(PixelFormat pf) +{ + switch (pf) + { + case PF_UNKNOWN: + return 0; + + case PF_R8G8B8: + case PF_R8G8B8F: + return GL_RGB; + + case PF_R8G8B8A8: + case PF_R8G8B8A8F: + return GL_RGBA; + } + + return 0; +} + +uint GetGLTypePF(PixelFormat pf) +{ + switch (pf) + { + case PF_UNKNOWN: + return 0; + + case PF_R8G8B8: + case PF_R8G8B8A8: + return GL_UNSIGNED_BYTE; + + case PF_R8G8B8F: + case PF_R8G8B8A8F: + return GL_FLOAT; + } + + return 0; +} #define LOAD_GL_FUNC(functype, funcname) \ { \ @@ -95,8 +179,112 @@ uint GetGLBlendFactor(BlendFactor factor) LogMsg("Failed to load %s", #funcname); \ } +bool GL_CheckExtensions(const char* name) +{ + const char* extensions = (const char*)glGetString(GL_EXTENSIONS); + if (strstr(extensions, name)) { + LogMsg("Found: %s", name); + return true; + } + + LogMsg("Not found: %s", name); + return false; +} + +void GL_CreateContext() +{ + // create opengl context + PIXELFORMATDESCRIPTOR pfd; + int iFormat; + + HWND hWnd = (HWND)R_GetWindow(); + + /* get the device context (DC) */ + hDC = GetDC(hWnd); + + /* set the pixel format for the DC */ + ZeroMemory(&pfd, sizeof(pfd)); + pfd.nSize = sizeof(pfd); + pfd.nVersion = 1; + pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; + pfd.iPixelType = PFD_TYPE_RGBA; + pfd.cColorBits = 24; + pfd.cDepthBits = 16; + pfd.iLayerType = PFD_MAIN_PLANE; + iFormat = ChoosePixelFormat(hDC, &pfd); + SetPixelFormat(hDC, iFormat, &pfd); + + LogMsg("SetPixelFormat successful"); + + /* create and enable the render context (RC) */ + hRC = wglCreateContext(hDC); + LogMsg("wglCreateContext successful"); + + wglMakeCurrent(hDC, hRC); +} + void GL_Load() { + GL_CreateContext(); + + const char* vendor_string = (const char*)glGetString(GL_VENDOR); + const char* renderer_string = (const char*)glGetString(GL_RENDERER); + const char* version_string = (const char*)glGetString(GL_VERSION); + const char* extensions_string = (const char*)glGetString(GL_EXTENSIONS); + + LogMsg("GL_VENDOR: %s", vendor_string); + LogMsg("GL_RENDERER: %s", renderer_string); + LogMsg("GL_VERSION: %s", version_string); + LogMsg("GL_EXTENSIONS: %s", extensions_string); + + // OpenGL 1.3 + LOAD_GL_FUNC( PFNGLACTIVETEXTUREPROC, glActiveTexture); + LOAD_GL_FUNC( PFNGLSAMPLECOVERAGEPROC, glSampleCoverage); + LOAD_GL_FUNC( PFNGLCOMPRESSEDTEXIMAGE3DPROC, glCompressedTexImage3D); + LOAD_GL_FUNC( PFNGLCOMPRESSEDTEXIMAGE2DPROC, glCompressedTexImage2D); + LOAD_GL_FUNC( PFNGLCOMPRESSEDTEXIMAGE1DPROC, glCompressedTexImage1D); + LOAD_GL_FUNC( PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC, glCompressedTexSubImage3D); + LOAD_GL_FUNC( PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC, glCompressedTexSubImage2D); + LOAD_GL_FUNC( PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC, glCompressedTexSubImage1D); + LOAD_GL_FUNC( PFNGLGETCOMPRESSEDTEXIMAGEPROC, glGetCompressedTexImage); + LOAD_GL_FUNC( PFNGLCLIENTACTIVETEXTUREPROC, glClientActiveTexture); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD1DPROC, glMultiTexCoord1d); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD1DVPROC, glMultiTexCoord1dv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD1FPROC, glMultiTexCoord1f); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD1FVPROC, glMultiTexCoord1fv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD1IPROC, glMultiTexCoord1i); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD1IVPROC, glMultiTexCoord1iv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD1SPROC, glMultiTexCoord1s); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD1SVPROC, glMultiTexCoord1sv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD2DPROC, glMultiTexCoord2d); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD2DVPROC, glMultiTexCoord2dv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD2FPROC, glMultiTexCoord2f); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD2FVPROC, glMultiTexCoord2fv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD2IPROC, glMultiTexCoord2i); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD2IVPROC, glMultiTexCoord2iv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD2SPROC, glMultiTexCoord2s); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD2SVPROC, glMultiTexCoord2sv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD3DPROC, glMultiTexCoord3d); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD3DVPROC, glMultiTexCoord3dv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD3FPROC, glMultiTexCoord3f); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD3FVPROC, glMultiTexCoord3fv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD3IPROC, glMultiTexCoord3i); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD3IVPROC, glMultiTexCoord3iv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD3SPROC, glMultiTexCoord3s); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD3SVPROC, glMultiTexCoord3sv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD4DPROC, glMultiTexCoord4d); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD4DVPROC, glMultiTexCoord4dv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD4FPROC, glMultiTexCoord4f); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD4FVPROC, glMultiTexCoord4fv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD4IPROC, glMultiTexCoord4i); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD4IVPROC, glMultiTexCoord4iv); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD4SPROC, glMultiTexCoord4s); + LOAD_GL_FUNC( PFNGLMULTITEXCOORD4SVPROC, glMultiTexCoord4sv); + LOAD_GL_FUNC( PFNGLLOADTRANSPOSEMATRIXFPROC, glLoadTransposeMatrixf); + LOAD_GL_FUNC( PFNGLLOADTRANSPOSEMATRIXDPROC, glLoadTransposeMatrixd); + LOAD_GL_FUNC( PFNGLMULTTRANSPOSEMATRIXFPROC, glMultTransposeMatrixf); + LOAD_GL_FUNC( PFNGLMULTTRANSPOSEMATRIXDPROC, glMultTransposeMatrixd); + // OpenGL 1.5 LOAD_GL_FUNC(PFNGLGENQUERIESPROC, glGenQueries); LOAD_GL_FUNC(PFNGLDELETEQUERIESPROC, glDeleteQueries); @@ -118,8 +306,87 @@ void GL_Load() LOAD_GL_FUNC(PFNGLGETBUFFERPARAMETERIVPROC, glGetBufferParameteriv); LOAD_GL_FUNC(PFNGLGETBUFFERPOINTERVPROC, glGetBufferPointerv); + //LogMsg("GL_Load: glActiveTexture=%i glGenBuffers=%i", !!glActiveTexture, !!glGenBuffers); + + g_EXTFramebufferSupport = GL_CheckExtensions("GL_EXT_framebuffer_object"); + if (g_EXTFramebufferSupport) + { + LOAD_GL_FUNC(PFNGLISRENDERBUFFEREXTPROC, glIsRenderbufferEXT); + LOAD_GL_FUNC(PFNGLBINDRENDERBUFFEREXTPROC, glBindRenderbufferEXT); + LOAD_GL_FUNC(PFNGLDELETERENDERBUFFERSEXTPROC, glDeleteRenderbuffersEXT); + LOAD_GL_FUNC(PFNGLGENRENDERBUFFERSEXTPROC, glGenRenderbuffersEXT); + LOAD_GL_FUNC(PFNGLRENDERBUFFERSTORAGEEXTPROC, glRenderbufferStorageEXT); + LOAD_GL_FUNC(PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC, glGetRenderbufferParameterivEXT); + LOAD_GL_FUNC(PFNGLISFRAMEBUFFEREXTPROC, glIsFramebufferEXT); + LOAD_GL_FUNC(PFNGLBINDFRAMEBUFFEREXTPROC, glBindFramebufferEXT); + LOAD_GL_FUNC(PFNGLDELETEFRAMEBUFFERSEXTPROC, glDeleteFramebuffersEXT); + LOAD_GL_FUNC(PFNGLGENFRAMEBUFFERSEXTPROC, glGenFramebuffersEXT); + LOAD_GL_FUNC(PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC, glCheckFramebufferStatusEXT); + LOAD_GL_FUNC(PFNGLFRAMEBUFFERTEXTURE1DEXTPROC, glFramebufferTexture1DEXT); + LOAD_GL_FUNC(PFNGLFRAMEBUFFERTEXTURE2DEXTPROC, glFramebufferTexture2DEXT); + LOAD_GL_FUNC(PFNGLFRAMEBUFFERTEXTURE3DEXTPROC, glFramebufferTexture3DEXT); + LOAD_GL_FUNC(PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC, glFramebufferRenderbufferEXT); + LOAD_GL_FUNC(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC, glGetFramebufferAttachmentParameterivEXT); + LOAD_GL_FUNC(PFNGLGENERATEMIPMAPEXTPROC, glGenerateMipmapEXT); + } } +void GL_SwapBuffers(int inverval) +{ +} + +// Extensions +bool g_EXTFramebufferSupport = false; + +// OpenGL 1.3 +PFNGLACTIVETEXTUREPROC glActiveTexture = NULL; +PFNGLSAMPLECOVERAGEPROC glSampleCoverage = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage = NULL; +PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture = NULL; +PFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d = NULL; +PFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv = NULL; +PFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f = NULL; +PFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv = NULL; +PFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i = NULL; +PFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv = NULL; +PFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s = NULL; +PFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv = NULL; +PFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d = NULL; +PFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv = NULL; +PFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f = NULL; +PFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv = NULL; +PFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i = NULL; +PFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv = NULL; +PFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s = NULL; +PFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv = NULL; +PFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d = NULL; +PFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv = NULL; +PFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f = NULL; +PFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv = NULL; +PFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i = NULL; +PFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv = NULL; +PFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s = NULL; +PFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv = NULL; +PFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d = NULL; +PFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv = NULL; +PFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f = NULL; +PFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv = NULL; +PFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i = NULL; +PFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv = NULL; +PFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s = NULL; +PFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv = NULL; +PFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf = NULL; +PFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd = NULL; +PFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf = NULL; +PFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd = NULL; + +// OpenGL 1.5 PFNGLGENQUERIESPROC glGenQueries = NULL; PFNGLDELETEQUERIESPROC glDeleteQueries = NULL; PFNGLISQUERYPROC glIsQuery = NULL; @@ -138,4 +405,23 @@ PFNGLGETBUFFERSUBDATAPROC glGetBufferSubData = NULL; PFNGLMAPBUFFERPROC glMapBuffer = NULL; PFNGLUNMAPBUFFERPROC glUnmapBuffer = NULL; PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv = NULL; -PFNGLGETBUFFERPOINTERVPROC glGetBufferPointerv = NULL; \ No newline at end of file +PFNGLGETBUFFERPOINTERVPROC glGetBufferPointerv = NULL; + +// GL_EXT_framebuffer_object +PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT = NULL; +PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT = NULL; +PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT = NULL; +PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT = NULL; +PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT = NULL; +PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT = NULL; +PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT = NULL; +PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT = NULL; +PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT = NULL; +PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT = NULL; +PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT = NULL; \ No newline at end of file diff --git a/engine/render/gl_shared.h b/engine/render/gl_shared.h index 79bf6eb..a0680a4 100644 --- a/engine/render/gl_shared.h +++ b/engine/render/gl_shared.h @@ -8,12 +8,13 @@ #include void GL_Load(); +void GL_SwapBuffers(int inverval); void GL_CheckError(); void GL_CheckErrorEx(const char* filename, int line); void GL_CheckErrorFunction(const char* expression, const char* filename, int line); -void GL_SetTexture( int slot, uint texture ); +//void GL_SetTexture( int slot, uint texture ); #define GL_CHECK_ERROR() \ GL_CheckErrorEx(__FILE__, __LINE__) @@ -22,8 +23,56 @@ void GL_SetTexture( int slot, uint texture ); expr; \ GL_CheckErrorFunction(#expr, __FILE__, __LINE__) -// OpenGL 1.3 Functional +// Extensions +extern bool g_EXTFramebufferSupport; +// OpenGL 1.3 Functional +extern PFNGLACTIVETEXTUREPROC glActiveTexture; +extern PFNGLSAMPLECOVERAGEPROC glSampleCoverage; +extern PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D; +extern PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D; +extern PFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D; +extern PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D; +extern PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D; +extern PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D; +extern PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage; +extern PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture; +extern PFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d; +extern PFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv; +extern PFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f; +extern PFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv; +extern PFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i; +extern PFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv; +extern PFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s; +extern PFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv; +extern PFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d; +extern PFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv; +extern PFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f; +extern PFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv; +extern PFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i; +extern PFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv; +extern PFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s; +extern PFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv; +extern PFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d; +extern PFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv; +extern PFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f; +extern PFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv; +extern PFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i; +extern PFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv; +extern PFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s; +extern PFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv; +extern PFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d; +extern PFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv; +extern PFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f; +extern PFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv; +extern PFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i; +extern PFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv; +extern PFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s; +extern PFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv; +extern PFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf; +extern PFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd; +extern PFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf; +extern PFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd; // OpenGL 1.5 Functional extern PFNGLGENQUERIESPROC glGenQueries; @@ -46,4 +95,23 @@ extern PFNGLUNMAPBUFFERPROC glUnmapBuffer; extern PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv; extern PFNGLGETBUFFERPOINTERVPROC glGetBufferPointerv; +// GL_EXT_framebuffer_object +extern PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT; +extern PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT; +extern PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT; +extern PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT; +extern PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT; +extern PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT; +extern PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT; +extern PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT; +extern PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT; +extern PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT; +extern PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT; +extern PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT; +extern PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT; +extern PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT; +extern PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT; +extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT; +extern PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT; + #endif // !GL_SHARED_H diff --git a/engine/render/render.cpp b/engine/render/render.cpp index 34d5796..a446940 100644 --- a/engine/render/render.cpp +++ b/engine/render/render.cpp @@ -1,14 +1,13 @@ #include "render/render.h" #include "render/renderdevice.h" #include "render/gl_shared.h" +#include "input/inputsystem.h" #include "utils/logger.h" #define RENDER_CLASS_NAME "RenderClassName" #define RENDER_WINDOW_NAME "UNEASE Alpha" HWND hWnd = NULL; -HDC hDC = NULL; -HGLRC hRC = NULL; LRESULT CALLBACK WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) @@ -75,33 +74,6 @@ void R_CreateWindow(int width, int height) LogMsg("Created window %ix%i", width, height); - - // create opengl context - PIXELFORMATDESCRIPTOR pfd; - int iFormat; - - /* get the device context (DC) */ - hDC = GetDC (hWnd); - - /* set the pixel format for the DC */ - ZeroMemory (&pfd, sizeof (pfd)); - pfd.nSize = sizeof (pfd); - pfd.nVersion = 1; - pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; - pfd.iPixelType = PFD_TYPE_RGBA; - pfd.cColorBits = 24; - pfd.cDepthBits = 16; - pfd.iLayerType = PFD_MAIN_PLANE; - iFormat = ChoosePixelFormat (hDC, &pfd); - SetPixelFormat (hDC, iFormat, &pfd); - - LogMsg("SetPixelFormat successful"); - - /* create and enable the render context (RC) */ - hRC = wglCreateContext( hDC ); - LogMsg("wglCreateContext successful"); - - wglMakeCurrent( hDC, hRC ); } void R_Init() @@ -129,5 +101,10 @@ void R_Shutdown() void R_Present() { - SwapBuffers(hDC); -} \ No newline at end of file + GL_SwapBuffers(0); +} + +void* R_GetWindow() +{ + return hWnd; +} diff --git a/engine/render/render.h b/engine/render/render.h index f1e8867..4e96ad2 100644 --- a/engine/render/render.h +++ b/engine/render/render.h @@ -8,4 +8,6 @@ void R_Shutdown(); void R_Present(); +void* R_GetWindow(); + #endif \ No newline at end of file diff --git a/engine/render/render_shared.h b/engine/render/render_shared.h index 8014980..80a9b7b 100644 --- a/engine/render/render_shared.h +++ b/engine/render/render_shared.h @@ -60,19 +60,19 @@ enum PrimitiveType enum TextureWrap { TW_REPEAT, - TW_MIRROREDREPEAT, - TW_CLAMPTOEDGE, - TW_CLAMPTOBORDER + TW_MIRRORED_REPEAT, + TW_CLAMP_TO_EDGE, + TW_CLAMP_TO_BORDER }; enum TextureFilter { TF_NEAREST, TF_LINEAR, - TF_NEARESTMIPMAPNEAREST, - TF_LINEARMIPMAPNEAREST, - TF_NEARESTMIPMAPLINEAR, - TF_LINEARMIPMAPLINEAR + TF_NEAREST_MIPMAP_NEAREST, + TF_LINEAR_MIPMAP_NEAREST, + TF_NEAREST_MIPMAP_LINEAR, + TF_LINEAR_MIPMAP_LINEAR }; // Base structure for render view (view and projection matrices, viewport settings) diff --git a/engine/render/renderdevice.cpp b/engine/render/renderdevice.cpp index c6868a4..0798445 100644 --- a/engine/render/renderdevice.cpp +++ b/engine/render/renderdevice.cpp @@ -8,7 +8,8 @@ #include "render/vertexbuffer.h" #include "render/indexbuffer.h" -//#include "render/rendertarget.h" +// Render Classes +#include "render/rendertarget.h" #include "render/renderdevice.h" RenderDevice* g_renderDevice = NULL; @@ -136,11 +137,11 @@ void RenderDevice::SetReadRenderTarget(RenderTarget* renderTarget) if (renderTarget) { if (m_activeReadRT != renderTarget) { m_activeReadRT = renderTarget; - glBindFramebuffer(GL_READ_FRAMEBUFFER, renderTarget->m_framebuffer); + glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, renderTarget->m_framebuffer); } } else { // set default rt - glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0); } } @@ -149,11 +150,11 @@ void RenderDevice::SetWriteRenderTarget(RenderTarget* renderTarget) if (renderTarget) { if (m_activeWriteRT != renderTarget) { m_activeWriteRT = renderTarget; - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, renderTarget->m_framebuffer); + glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, renderTarget->m_framebuffer); } } else { // set default rt - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); + glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0); } } diff --git a/engine/render/rendertarget.cpp b/engine/render/rendertarget.cpp index 16c587f..cc56249 100644 --- a/engine/render/rendertarget.cpp +++ b/engine/render/rendertarget.cpp @@ -1,12 +1,12 @@ #include #include "render/rendertarget.h" - #include "render/texturesmanager.h" #include "render/texture2d.h" +#include "render/gl_shared.h" void RenderTarget::setDefaultFramebuffer() { - glBindFramebuffer(GL_FRAMEBUFFER, 0); + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } RenderTarget::RenderTarget() @@ -19,7 +19,7 @@ RenderTarget::~RenderTarget() m_framebuffer = -1; } -void RenderTarget::create(const char* name /*= nullptr*/) +void RenderTarget::Create(const char* name /*= nullptr*/) { assert(g_texturesManager); @@ -27,35 +27,35 @@ void RenderTarget::create(const char* name /*= nullptr*/) // Create FBO // generate frame buffer - glGenFramebuffers(1, &m_framebuffer); - glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); + glGenFramebuffersEXT(1, &m_framebuffer); + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_framebuffer); } -void RenderTarget::destroy() +void RenderTarget::Destroy() { GLint drawFboId; glGetIntegerv(GL_FRAMEBUFFER_BINDING, &drawFboId); if (drawFboId == (GLint)m_framebuffer) - glBindFramebuffer(GL_FRAMEBUFFER, 0); - glDeleteFramebuffers(1, &m_framebuffer); + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + glDeleteFramebuffersEXT(1, &m_framebuffer); } -void RenderTarget::finialize() +void RenderTarget::Finialize() { - if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { - assert(0 && "RenderTarget::finialize: failed to finialize framebuffer. Framebuffer is not complete"); + if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) { + assert(0 && "RenderTarget::Finialize: failed to Finialize framebuffer. Framebuffer is not complete"); } } -void RenderTarget::attachColorTexture(int slot, Texture2D* texture) +void RenderTarget::AttachColorTexture(int slot, Texture2D* texture) { assert(texture && "Failed to assing nullptr texture"); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + slot, GL_TEXTURE_2D, texture->GetHandle(), 0); + glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0 + slot, GL_TEXTURE_2D, texture->GetHandle(), 0); } -void RenderTarget::attachDepthTexture(Texture2D* texture) +void RenderTarget::AttachDepthTexture(Texture2D* texture) { assert(texture && "Failed to assing nullptr texture"); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texture->GetHandle(), 0); + glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texture->GetHandle(), 0); } diff --git a/engine/render/rendertarget.h b/engine/render/rendertarget.h index 302dcaf..275ea40 100644 --- a/engine/render/rendertarget.h +++ b/engine/render/rendertarget.h @@ -17,13 +17,13 @@ public: RenderTarget(); ~RenderTarget(); - void create(const char* name = nullptr); - void destroy(); + void Create(const char* name = nullptr); + void Destroy(); - void finialize(); + void Finialize(); - void attachColorTexture(int slot, Texture2D* texture); - void attachDepthTexture(Texture2D* texture); + void AttachColorTexture(int slot, Texture2D* texture); + void AttachDepthTexture(Texture2D* texture); private: uint32_t m_framebuffer; diff --git a/engine/render/texture2d.cpp b/engine/render/texture2d.cpp index 8b57f2f..f1d788f 100644 --- a/engine/render/texture2d.cpp +++ b/engine/render/texture2d.cpp @@ -118,7 +118,7 @@ void Texture2D::CreateRaw(void* data, int width, int height, PixelFormat pf) glGenTextures(1, &m_handle); glBindTexture(GL_TEXTURE_2D, m_handle); - glTexImage2D(GL_TEXTURE_2D, 0, getGLInternalPF(pf), width, height, 0, getGLInternalPF(pf), GL_UNSIGNED_BYTE, data); + glTexImage2D(GL_TEXTURE_2D, 0, GetGLInternalPF(pf), width, height, 0, GetGLInternalPF(pf), GL_UNSIGNED_BYTE, data); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); @@ -131,6 +131,9 @@ void Texture2D::CreateRaw(void* data, int width, int height, PixelFormat pf) void Texture2D::GenerateMipmaps() { + assert(0 && "Not Implemented"); + +#if 0 glBindTexture(GL_TEXTURE_2D, m_handle); glGenerateMipmap(GL_TEXTURE_2D); @@ -142,6 +145,7 @@ void Texture2D::GenerateMipmaps() //} glBindTexture(GL_TEXTURE_2D, 0); +#endif } void Texture2D::Bind() @@ -151,105 +155,24 @@ void Texture2D::Bind() void Texture2D::SetWrapS(TextureWrap wrap) { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, getGlWrap(wrap)); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GetGlWrap(wrap)); } void Texture2D::SetWrapT(TextureWrap wrap) { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, getGlWrap(wrap)); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GetGlWrap(wrap)); } void Texture2D::SetMin(TextureFilter filter) { GLint param = 0; - param = getGlTexFilter(filter); + param = GetGlTexFilter(filter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, param); } void Texture2D::SetMag(TextureFilter filter) { GLint param = 0; - param = getGlTexFilter(filter); + param = GetGlTexFilter(filter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, param); } - -GLint GetGlWrap(TextureWrap wrap) -{ - GLint param = 0; - - if (wrap == TextureWrap::Repeat) - param = GL_REPEAT; - else if (wrap == TextureWrap::MirroredRepeat) - param = GL_MIRRORED_REPEAT; - else if (wrap == TextureWrap::ClampToEdge) - param = GL_CLAMP_TO_EDGE; - else if (wrap == TextureWrap::ClampToBorder) - param = GL_CLAMP_TO_BORDER; - - return param; -} - -GLint GetGlTexFilter(TextureFilter filter) -{ - GLint param = 0; - - if (filter == TextureFilter::Linear) - param = GL_LINEAR; - else if (filter == TextureFilter::Nearest) - param = GL_NEAREST; - else if (filter == TextureFilter::LinearMipmapLinear) - param = GL_LINEAR_MIPMAP_LINEAR; - else if (filter == TextureFilter::LinearMipmapNearest) - param = GL_LINEAR_MIPMAP_NEAREST; - else if (filter == TextureFilter::NearestMipmapLinear) - param = GL_NEAREST_MIPMAP_LINEAR; - else if (filter == TextureFilter::NearestMipmapNearest) - param = GL_NEAREST_MIPMAP_NEAREST; - - return param; -} - -uint getGLPF(PixelFormat pf) -{ - return 0; - //return uint32_t(); -} - -// Kirill: Remove to render_main.cpp or something else -uint getGLInternalPF(PixelFormat pf) -{ - switch (pf) - { - case PF_UNKNOWN: - return 0; - - case PF_R8G8B8: - case PF_R8G8B8F: - return GL_RGB; - - case PF_R8G8B8A8: - case PF_R8G8B8A8F: - return GL_RGBA; - } - - return 0; -} - -uint getGLTypePF(PixelFormat pf) -{ - switch (pf) - { - case PF_UNKNOWN: - return 0; - - case PF_R8G8B8: - case PF_R8G8B8A8: - return GL_UNSIGNED_BYTE; - - case PF_R8G8B8F: - case PF_R8G8B8A8F: - return GL_FLOAT; - } - - return 0; -} diff --git a/engine/render/texturesmanager.cpp b/engine/render/texturesmanager.cpp index b6d874f..a724eca 100644 --- a/engine/render/texturesmanager.cpp +++ b/engine/render/texturesmanager.cpp @@ -67,10 +67,10 @@ void TexturesManager::Init() void TexturesManager::Shutdown() { if (!m_textures.empty()) { - Msg("--- unfreed textures ---"); + LogMsg("--- unfreed textures ---"); for (std::vector::iterator it = m_textures.begin(); it != m_textures.end(); ++it) { - Msg("%s", (*it)->m_textureFileName.c_str()); + LogMsg("%s", (*it)->m_textureFileName.c_str()); delete* it; *it = NULL; } @@ -99,7 +99,7 @@ Texture2D* TexturesManager::CreateManual2D(const char* name, int width, int heig texture->m_textureFileName = name; if (useAsRenderTarget) - Msg("Created rt texture [%s]", name); + LogMsg("Created rt texture [%s]", name); return texture; } @@ -179,12 +179,12 @@ Texture2D* TexturesManager::LoadTexture2D(const char* texturename, bool useMipma if (useMipmaps) texture->GenerateMipmaps(); - Msg("loaded %s", fs::getFilenameWithoutPathAndExtension(texturename).c_str()); + LogMsg("loaded %s", fs::getFilenameWithoutPathAndExtension(texturename).c_str()); m_textures.push_back(texture); return texture; } else if (texnamebuf.empty() && m_notex) { - Msg("not found %s", fs::getFilenameWithoutPathAndExtension(texturename).c_str()); + LogMsg("not found %s", fs::getFilenameWithoutPathAndExtension(texturename).c_str()); return m_notex; } diff --git a/engine/server/entity.cpp b/engine/server/entity.cpp new file mode 100644 index 0000000..90dd12e --- /dev/null +++ b/engine/server/entity.cpp @@ -0,0 +1,59 @@ +#include "utils/logger.h" + +#include "server/entity.h" + +IMPLEMENT_RTTI_BASE( Entity ); + +Entity::Entity() : + m_position(0.0f), m_rotation(0.0f), m_scale(1.0f), + m_model(nullptr) +{ +} + +Entity::~Entity() +{ +} + +void Entity::LoadModel(const char* filename) +{ + //m_model = g_modelManager->LoadModel(filename); + //if (!m_model) + //{ + // Msg("Failed to load %s, no physic or animation", filename); + // return; + //} + + //// get model bounds + //m_boundingBox = m_model->GetBoundingBox(); +} + +IMPLEMENT_RTTI( LightEntity, Entity ); + +LightEntity::LightEntity() +{ +} + +LightEntity::~LightEntity() +{ +} + +void TestRTTI() +{ + Entity* entity = new Entity(); + LogMsg("entity classname: %s", entity->GetRuntimeClass()->m_pClassName); + + LightEntity* light = new LightEntity(); + LogMsg("light classname: %s", light->GetRuntimeClass()->m_pClassName); + + LightEntity* lightCasted = DynamicCast< LightEntity, Entity >( entity ); + LogMsg("light from entity casted: %s", lightCasted ? "successful" : "failed"); + + delete entity; + entity = light; + + lightCasted = DynamicCast< LightEntity, Entity >( entity ); + LogMsg("light from entity(LightEntity) casted: %s", lightCasted ? "successful" : "failed"); + + entity = NULL; + delete light; +} diff --git a/engine/server/entity.h b/engine/server/entity.h new file mode 100644 index 0000000..3746049 --- /dev/null +++ b/engine/server/entity.h @@ -0,0 +1,58 @@ +#ifndef GAME_OBJECT_H +#define GAME_OBJECT_H + +#include "utils/rtti.h" +#include "utils/maths.h" +#include "utils/str.h" + +class Model; + +enum EntityComponents +{ + ENTITY_COMPONENTS_NONE, + ENTITY_COMPONENTS_VISUAL, + ENTITY_COMPONENTS_PHYSICS, + ENTITY_COMPONENTS_COLLIDER, + ENTITY_COMPONENTS_TRIGGER, + ENTITY_COMPONENTS_GHOST, + ENTITY_COMPONENTS_SOUND, + ENTITY_COMPONENTS_PARTICLESYSTEM, + + ENTITY_COMPONENTS_MAX +}; + +class Entity +{ +public: + DECLARE_RTTI; + +public: + Entity(); + ~Entity(); + + virtual void LoadModel(const char* filename); + +public: + Str m_name; + + Vec3 m_position; + Vec3 m_rotation; + Vec3 m_scale; + + Model* m_model; + +}; + +class LightEntity : public Entity +{ +public: + DECLARE_RTTI; + +public: + LightEntity(); + ~LightEntity(); +}; + +void TestRTTI(); + +#endif // !GAME_OBJECT_H diff --git a/engine/utils/logger.h b/engine/utils/logger.h index 733f782..37ba64f 100644 --- a/engine/utils/logger.h +++ b/engine/utils/logger.h @@ -10,7 +10,6 @@ public: static void Error(const char* msg, ...); }; -#define Msg Logger::LogPrint #define LogMsg Logger::LogPrint #endif // !LOGGER_H diff --git a/engine/utils/maths.h b/engine/utils/maths.h index 591d0ca..39684b5 100644 --- a/engine/utils/maths.h +++ b/engine/utils/maths.h @@ -25,4 +25,15 @@ struct Point2 int y; }; +struct Vec3 +{ + float x; + float y; + float z; + + Vec3() { x = y = z = 0.f; } + Vec3(float value) { x = y = z = value; } + Vec3(float _x, float _y, float _z) { x = _x; y = _y; z = _z; } +}; + #endif // !MATHS_H diff --git a/engine/utils/rtti.h b/engine/utils/rtti.h index 4075fc8..0d980a8 100644 --- a/engine/utils/rtti.h +++ b/engine/utils/rtti.h @@ -1,141 +1,66 @@ -/* - -The other day we tracked a bad bug where a base class was been cast to -the wrong thing. -The reason why it happed was because we didn't have any RTTI (Run Time -Type Information) in place. -We also didn't want to use the one that it comes with the compiler for -fear that it will add "evil" code. -So after hitting that bug I decided to do my on RTTI. I wanted to be -simple and very fast. -This is what we use now. It looks kind of neat so I thought to share it. -Enjoy. - -Tomas -tarce@zen-x.net - -*/ +#ifndef RTTI_H +#define RTTI_H #include #include #include + //============================================================================== // RTTI //============================================================================== -// Using the RTTI -//------------------------------------------------------------------------------ -// struct base -// { -// CREATE_RTTI_BASE( base ); -// }; -// -// struct pepe : public base -// { -// CREATE_RTTI( pepe, base, base ) -// void Normal( void ){} -// }; -// -// struct super_pepe : public pepe -// { -// CREATE_RTTI( super_pepe, pepe, base ) -// void Super( void ){} -// }; -// -// void main( void ) -// { -// super_pepe SP; // The original class -// base& B = SP; // Some generic base reference -// -// // We want to safely convert to pepe -// pepe& P = pepe::GetSaveType( B ); -// -// // cast the base class right -// if( B.IsKindOf( super_pepe::GetRTTI() ) ) -// { -// super_pepe& SP = super_pepe::GetSaveType( B ); -// SP.Super(); -// } -// else if( B.IsKindOf( pepe::GetRTTI() ) ) -// { -// pepe& P = pepe::GetSaveType( B ); -// P.Normal(); -// } -// } -//============================================================================== -#define CREATE_RTTI( TYPE, BASE_CLASS ) -#define CREATE_RTTI_BASE( TYPE ) - -struct RTTI +struct RuntimeClass { - bool IsKindOf( const RTTI& RTTI ) const; - RTTI ( const char* pTypeName ); - RTTI ( const char* pTypeName, const RTTI& RTTI ); - - const char* pType; // This is not really need it, just useful in debugger. - const RTTI& Next; + bool IsKindOf(const RuntimeClass* pRuntimeClass) const; + RuntimeClass(const char* pClassName); + RuntimeClass(const char* pClassName, const RuntimeClass* pBaseClass); + + const char* m_pClassName; + const RuntimeClass* m_pBaseClass; }; - + +#define DECLARE_RTTI \ + static RuntimeClass ms_RuntimeClass; \ + virtual RuntimeClass* GetRuntimeClass() \ + { \ + return &ms_RuntimeClass; \ + } + +#define IMPLEMENT_RTTI_BASE( Class ) \ + RuntimeClass Class::ms_RuntimeClass( #Class ) \ + +#define IMPLEMENT_RTTI( Class, BaseClass ) \ + RuntimeClass Class::ms_RuntimeClass( #Class, &BaseClass::ms_RuntimeClass ) \ + //============================================================================== // IMPLEMENTATION //============================================================================== -#pragma warning( push ) -#pragma warning( disable : 4355 ) // warning 'this' used in base member initializer list -#undef CREATE_RTTI -#undef CREATE_RTTI_BASE +inline RuntimeClass::RuntimeClass( const char* pClassName) : +m_pClassName(pClassName), m_pBaseClass( NULL ){} -inline RTTI::RTTI( const char* pTypeName ) : -pType(pTypeName), Next( *this ){} +inline RuntimeClass::RuntimeClass( const char* pClassName, const RuntimeClass* pBaseClass ) : +m_pClassName(pClassName), m_pBaseClass( pBaseClass ){} -inline RTTI::RTTI( const char* pTypeName, const RTTI& RTTI ) : -pType(pTypeName), Next( RTTI ){} - -inline bool RTTI::IsKindOf( const RTTI& RTTI ) const +inline bool RuntimeClass::IsKindOf( const RuntimeClass* pRuntimeClass ) const { - const RTTI* p = this; - do - { - if( p == &RTTI ) return true; - if( p == &p->Next ) break; - p = &p->Next; - - } while(1); + const RuntimeClass* p = this; + while (p) + { + if ( p == pRuntimeClass ) + return true; + + p = p->m_pBaseClass; + } + return false; } - -#define PRIVATE_RTTI_FUNCTION_SET( TYPE, BASE_CLASS ) \ - virtual inline const RTTI& GetObjectRTTI( void ) const \ - { \ - return TYPE::GetRTTI(); \ - } \ - inline const bool IsKindOf( const RTTI& RTTI ) const \ - { \ - return GetObjectRTTI().IsKindOf( RTTI ); \ - } \ - static inline TYPE& GetSaveType( BASE_CLASS& Object ) \ - { \ - assert( Object.IsKindOf(TYPE::GetRTTI()) ); \ - return *((TYPE*)&Object); \ - } \ - static inline const TYPE& GetSaveType( const BASE_CLASS& Object ) \ - { \ - assert( Object.IsKindOf(TYPE::GetRTTI()) ); \ - return *((const TYPE*)&Object); \ - } - -#define CREATE_RTTI( TYPE, TYPE_PARENT, BASE_CLASS ) \ - static inline const RTTI& GetRTTI( void ) \ - { \ - static RTTI s_RTTI( #TYPE, TYPE_PARENT::GetRTTI() ); \ - return s_RTTI; \ - } \ - PRIVATE_RTTI_FUNCTION_SET(TYPE,BASE_CLASS) - -#define CREATE_RTTI_BASE( TYPE ) \ - static inline const RTTI& GetRTTI( void ) \ - { \ - static RTTI s_RTTI( #TYPE ); \ - return s_RTTI; \ - } \ - PRIVATE_RTTI_FUNCTION_SET(TYPE,TYPE) - -#pragma warning( pop ) + +template +T* DynamicCast(C* pObj) +{ + if ( pObj->GetRuntimeClass()->IsKindOf( &T::ms_RuntimeClass ) ) + return (T*)pObj; + + return 0; +} + +#endif // !RTTI_H diff --git a/engine/utils/str.h b/engine/utils/str.h new file mode 100644 index 0000000..387fcfe --- /dev/null +++ b/engine/utils/str.h @@ -0,0 +1,139 @@ +#ifndef CSTR_H +#define CSTR_H + +#include +#include +#include + +class Str +{ +public: + Str() + { + m_Text = NULL; + } + + Str( const Str& source ) + { + m_Text = NULL; + if ( source.m_Text != NULL ) + Copy( source.m_Text ); + } + + Str( const char* source ) + { + m_Text = NULL; + if ( source != NULL ) + Copy( source ); + } + + ~Str() + { + Free(); + } + + void Free() + { + if ( m_Text != NULL ) + { + free( m_Text ); + m_Text = NULL; + } + } + + void Copy( const char* source ) + { + Reserve( strlen( source ) + 1 ); + strcpy( m_Text, source ); + } + + void Reserve( unsigned int size ) + { + if (m_Text) + { + free( m_Text ); + } + + m_Text = (char*)malloc( size ); + } + + Str& operator=( const char* source ) + { + Free(); + + if ( source != NULL ) + Copy( source ); + + return *this; + } + + int Compare( const Str& string ) const + { + if ( m_Text == NULL && string.m_Text == NULL ) + return 0; + + if ( m_Text == NULL || string.m_Text == NULL ) + return -1; + + return strcmp( m_Text, string.m_Text ); + } + + int Compare( const char* string ) const + { + if ( m_Text == NULL && string == NULL ) + return 0; + + if ( m_Text == NULL || string == NULL ) + return -1; + + return strcmp( m_Text, string ); + } + + friend bool operator==( const Str& stringA, const Str& stringB ) + { + return stringA.Compare( stringB ) == 0; + } + + friend bool operator==( const Str& stringA, const char* stringB ) + { + return stringA.Compare( stringB ) == 0; + } + + friend bool operator==( const char* stringA, const Str& stringB ) + { + return stringB.Compare( stringA ) == 0; + } + + char& operator[]( const size_t idx ) + { + return m_Text[idx]; + } + + void Clear() + { + Free(); + } + + bool IsEmpty() + { + return GetLength() == 0; + } + + unsigned int GetLength() + { + if ( m_Text == NULL ) + return 0; + + return strlen( m_Text ); + } + + const char* GetText() + { + return (const char*)m_Text; + } + +private: + char* m_Text; +}; + +#endif // !CSTR_H \ No newline at end of file diff --git a/tools/premake5.exe b/tools/premake5.exe new file mode 100644 index 0000000..1a637aa Binary files /dev/null and b/tools/premake5.exe differ