ugo_zapad/unease
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Big changes

Browse Source
This commit is contained in:
Kirill Yurkin
2025-03-07 16:54:27 +03:00
parent dd05797b95
commit 719171e7d8
21 changed files with 817 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/build

1
engine/gen_vs2022.bat Normal file
View File

@@ -0,0 +1 @@
..\tools\premake5.exe vs2022

6
engine/main.cpp
View File

@@ -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))
{

76
engine/premake5.lua Normal file
View File

@@ -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" }

292
engine/render/gl_shared.cpp
View File

@@ -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;
@@ -139,3 +406,22 @@ PFNGLMAPBUFFERPROC glMapBuffer = NULL;
PFNGLUNMAPBUFFERPROC glUnmapBuffer = NULL;
PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv = NULL;
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;

72
engine/render/gl_shared.h
View File

@@ -8,12 +8,13 @@
#include <gl/glext.h>
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

37
engine/render/render.cpp
View File

@@ -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);
GL_SwapBuffers(0);
}
void* R_GetWindow()
{
return hWnd;
}

2
engine/render/render.h
View File

@@ -8,4 +8,6 @@ void R_Shutdown();
void R_Present();
void* R_GetWindow();
#endif

14
engine/render/render_shared.h
View File

@@ -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)

11
engine/render/renderdevice.cpp
View File

@@ -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);
}
}

30
engine/render/rendertarget.cpp
View File

@@ -1,12 +1,12 @@
#include <assert.h>
#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);
}

10
engine/render/rendertarget.h
View File

@@ -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;

95
engine/render/texture2d.cpp
View File

@@ -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;
}

10
engine/render/texturesmanager.cpp
View File

@@ -67,10 +67,10 @@ void TexturesManager::Init()
void TexturesManager::Shutdown()
{
if (!m_textures.empty()) {
Msg("--- unfreed textures ---");
LogMsg("--- unfreed textures ---");
for (std::vector<Texture2D*>::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;
}

59
engine/server/entity.cpp Normal file
View File

@@ -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;
}

58
engine/server/entity.h Normal file
View File

@@ -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

1
engine/utils/logger.h
View File

@@ -10,7 +10,6 @@ public:
static void Error(const char* msg, ...);
};
#define Msg Logger::LogPrint
#define LogMsg Logger::LogPrint
#endif // !LOGGER_H

11
engine/utils/maths.h
View File

@@ -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

159
engine/utils/rtti.h
View File

@@ -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 <stdlib.h>
#include <assert.h>
#include <string.h>
//==============================================================================
// 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 );
bool IsKindOf(const RuntimeClass* pRuntimeClass) const;
RuntimeClass(const char* pClassName);
RuntimeClass(const char* pClassName, const RuntimeClass* pBaseClass);
const char* pType; // This is not really need it, just useful in debugger.
const RTTI& Next;
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
const RuntimeClass* p = this;
while (p)
{
if( p == &RTTI ) return true;
if( p == &p->Next ) break;
p = &p->Next;
if ( p == pRuntimeClass )
return true;
p = p->m_pBaseClass;
}
} while(1);
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); \
}
template <typename T, typename C>
T* DynamicCast(C* pObj)
{
if ( pObj->GetRuntimeClass()->IsKindOf( &T::ms_RuntimeClass ) )
return (T*)pObj;
#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)
return 0;
}
#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 )
#endif // !RTTI_H

139
engine/utils/str.h Normal file
View File

@@ -0,0 +1,139 @@
#ifndef CSTR_H
#define CSTR_H
#include <stdlib.h>
#include <memory.h>
#include <string.h>
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

BIN
tools/premake5.exe Normal file
View File

Binary file not shown.