jetomit/avp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Import icculus.org release (2017-05-05)

Browse source
This commit is contained in:
Steven Fuller 2017-05-05 12:00:00 +02:00 • committed by Patryk Obara
parent 0de664d0a8
commit 5673c1665a
26 changed files with 2211 additions and 824 deletions
Download patch file Download diff file Expand all files Collapse all files

316
CMakeLists.txt
View file

@ -9,117 +9,148 @@ IF(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo") SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
ENDIF(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) ENDIF(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
# default to Desktop build
IF(NOT AVP_BUILD_TYPE)
SET(AVP_BUILD_TYPE DESKTOP CACHE STRING "Executable type; one of: DESKTOP WEB" FORCE)
ENDIF(NOT AVP_BUILD_TYPE)
IF(NOT AVP_BUILD_TYPE STREQUAL "DESKTOP" AND NOT AVP_BUILD_TYPE STREQUAL "WEB")
MESSAGE(FATAL_ERROR "Invalid AVP_BUILD_TYPE setting ${AVP_BUILD_TYPE}; must be one of DESKTOP WEB")
ENDIF(NOT AVP_BUILD_TYPE STREQUAL "DESKTOP" AND NOT AVP_BUILD_TYPE STREQUAL "WEB")
SET(AVP_WEB "NO")
IF(AVP_BUILD_TYPE STREQUAL "WEB")
SET(AVP_WEB "YES")
ENDIF(AVP_BUILD_TYPE STREQUAL "WEB")
PROJECT(avp) PROJECT(avp)
IF(AVP_WEB)
IF(CMAKE_BUILD_TYPE STREQUAL "Debug")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -g4 -s USE_SDL=2 -s TOTAL_MEMORY=234881024 -s ASSERTIONS=2 -s SAFE_HEAP=1 -s STACK_OVERFLOW_CHECK=2 -s DEMANGLE_SUPPORT=1")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -g4 -s USE_SDL=2 -s TOTAL_MEMORY=234881024 -s ASSERTIONS=2 -s SAFE_HEAP=1 -s STACK_OVERFLOW_CHECK=2 -s DEMANGLE_SUPPORT=1")
ELSE()
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -s USE_SDL=2 -s TOTAL_MEMORY=234881024")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s USE_SDL=2 -s TOTAL_MEMORY=234881024")
ENDIF()
IF(AVP_WEB_WASM)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -s WASM=1")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s WASM=1")
ENDIF()
ENDIF(AVP_WEB)
# required dependencies # required dependencies
INCLUDE(FindOpenGLES.cmake) IF(NOT AVP_WEB)
INCLUDE(FindOpenGLES2.cmake) INCLUDE(FindOpenGLES2.cmake)
INCLUDE(FindSDL2.cmake) INCLUDE(FindSDL2.cmake)
INCLUDE(FindSDL) INCLUDE(FindSDL)
INCLUDE(FindOpenGL) INCLUDE(FindOpenGL)
INCLUDE(FindOpenAL) INCLUDE(FindOpenAL)
# Use SDL 1.2 if it is installed, else use SDL 2.0. # Use SDL 1.2 if it is installed, else use SDL 2.0.
IF(NOT SDL_TYPE) IF(NOT SDL_TYPE)
SET(SDL_TYPE AUTO CACHE STRING "SDL Version; one of: AUTO SDL SDL2") SET(SDL_TYPE AUTO CACHE STRING "SDL Version; one of: AUTO SDL SDL2")
SET_PROPERTY(CACHE SDL_TYPE PROPERTY STRINGS "AUTO" "SDL" "SDL2") SET_PROPERTY(CACHE SDL_TYPE PROPERTY STRINGS "AUTO" "SDL" "SDL2")
ENDIF(NOT SDL_TYPE) ENDIF(NOT SDL_TYPE)
IF(NOT SDL_TYPE STREQUAL "AUTO" AND NOT SDL_TYPE STREQUAL "SDL" AND NOT SDL_TYPE STREQUAL "SDL2") IF(NOT SDL_TYPE STREQUAL "AUTO" AND NOT SDL_TYPE STREQUAL "SDL" AND NOT SDL_TYPE STREQUAL "SDL2")
MESSAGE(FATAL_ERROR "Invalid SDL_TYPE setting ${SDL_TYPE}; must be one of AUTO SDL SDL2") MESSAGE(FATAL_ERROR "Invalid SDL_TYPE setting ${SDL_TYPE}; must be one of AUTO SDL SDL2")
ENDIF(NOT SDL_TYPE STREQUAL "AUTO" AND NOT SDL_TYPE STREQUAL "SDL" AND NOT SDL_TYPE STREQUAL "SDL2") ENDIF(NOT SDL_TYPE STREQUAL "AUTO" AND NOT SDL_TYPE STREQUAL "SDL" AND NOT SDL_TYPE STREQUAL "SDL2")
IF(SDL_FOUND)
IF(SDL_VERSION_STRING VERSION_LESS "1.2.0")
MESSAGE(WARNING "SDL 1.2 was claimed to be found with version ${SDL_VERSION_STRING}, ignoring...")
UNSET(SDL_FOUND)
ENDIF(SDL_VERSION_STRING VERSION_LESS "1.2.0")
IF(SDL_VERSION_STRING VERSION_GREATER "1.2.99")
MESSAGE(WARNING "SDL 1.2 was claimed to be found with version ${SDL_VERSION_STRING}, ignoring...")
UNSET(SDL_FOUND)
ENDIF(SDL_VERSION_STRING VERSION_GREATER "1.2.99")
ENDIF(SDL_FOUND)
IF(SDL_TYPE STREQUAL "AUTO")
IF(SDL_FOUND) IF(SDL_FOUND)
MESSAGE(STATUS "SDL 1.2 found; using that.") IF(SDL_VERSION_STRING VERSION_LESS "1.2.0")
SET(SDL_TYPE "SDL") MESSAGE(WARNING "SDL 1.2 was claimed to be found with version ${SDL_VERSION_STRING}, ignoring...")
UNSET(SDL_FOUND)
ENDIF(SDL_VERSION_STRING VERSION_LESS "1.2.0")
IF(SDL_VERSION_STRING VERSION_GREATER "1.2.99")
MESSAGE(WARNING "SDL 1.2 was claimed to be found with version ${SDL_VERSION_STRING}, ignoring...")
UNSET(SDL_FOUND)
ENDIF(SDL_VERSION_STRING VERSION_GREATER "1.2.99")
ENDIF(SDL_FOUND) ENDIF(SDL_FOUND)
ENDIF(SDL_TYPE STREQUAL "AUTO")
IF(SDL_TYPE STREQUAL "AUTO") IF(SDL_TYPE STREQUAL "AUTO")
IF(SDL2_FOUND) IF(SDL_FOUND)
MESSAGE(STATUS "SDL 2.0 found; using that.") MESSAGE(STATUS "SDL 1.2 found; using that.")
SET(SDL_TYPE "SDL2") SET(SDL_TYPE "SDL")
ENDIF(SDL2_FOUND) ENDIF(SDL_FOUND)
ENDIF(SDL_TYPE STREQUAL "AUTO") ENDIF(SDL_TYPE STREQUAL "AUTO")
IF(SDL_TYPE STREQUAL "AUTO") IF(SDL_TYPE STREQUAL "AUTO")
MESSAGE(FATAL_ERROR "SDL 1.2 or SDL 2.0 is required but CMake couldn't find it.") IF(SDL2_FOUND)
ENDIF(SDL_TYPE STREQUAL "AUTO") MESSAGE(STATUS "SDL 2.0 found; using that.")
SET(SDL_TYPE "SDL2")
ENDIF(SDL2_FOUND)
ENDIF(SDL_TYPE STREQUAL "AUTO")
IF(SDL_TYPE STREQUAL "SDL") IF(SDL_TYPE STREQUAL "AUTO")
IF(NOT SDL_FOUND) MESSAGE(FATAL_ERROR "SDL 1.2 or SDL 2.0 is required but CMake couldn't find it.")
MESSAGE(FATAL_ERROR "SDL 1.2 was requested but CMake couldn't find it.") ENDIF(SDL_TYPE STREQUAL "AUTO")
ENDIF(NOT SDL_FOUND)
ENDIF(SDL_TYPE STREQUAL "SDL")
IF(SDL_TYPE STREQUAL "SDL2") IF(SDL_TYPE STREQUAL "SDL")
IF(NOT SDL2_FOUND) IF(NOT SDL_FOUND)
MESSAGE(FATAL_ERROR "SDL 2.0 was requested but CMake couldn't find it.") MESSAGE(FATAL_ERROR "SDL 1.2 was requested but CMake couldn't find it.")
ENDIF(NOT SDL2_FOUND) ENDIF(NOT SDL_FOUND)
MESSAGE(WARNING "SDL 2.0 support is EXPERIMENTAL and INCOMPLETE.") ENDIF(SDL_TYPE STREQUAL "SDL")
ENDIF(SDL_TYPE STREQUAL "SDL2")
# Use Desktop OpenGL if it is available, else try OpenGL ES. IF(SDL_TYPE STREQUAL "SDL2")
IF(NOT OPENGL_TYPE) IF(NOT SDL2_FOUND)
SET(OPENGL_TYPE AUTO CACHE STRING "OpenGL Version; one of: AUTO OPENGL OPENGLES") MESSAGE(FATAL_ERROR "SDL 2.0 was requested but CMake couldn't find it.")
SET_PROPERTY(CACHE OPENGL_TYPE PROPERTY STRINGS "AUTO" "OPENGL" "OPENGLES") ENDIF(NOT SDL2_FOUND)
ENDIF(NOT OPENGL_TYPE) MESSAGE(WARNING "SDL 2.0 support is EXPERIMENTAL and INCOMPLETE.")
ENDIF(SDL_TYPE STREQUAL "SDL2")
IF(NOT OPENGL_TYPE STREQUAL "AUTO" AND NOT OPENGL_TYPE STREQUAL "OPENGL" AND NOT OPENGL_TYPE STREQUAL "OPENGLES") # Use Desktop OpenGL if it is available, else try OpenGL ES 2.0.
MESSAGE(FATAL_ERROR "Invalid OPENGL_TYPE setting ${OPENGL_TYPE}; must be one of AUTO OPENGL OPENGLES") IF(NOT OPENGL_TYPE)
ENDIF(NOT OPENGL_TYPE STREQUAL "AUTO" AND NOT OPENGL_TYPE STREQUAL "OPENGL" AND NOT OPENGL_TYPE STREQUAL "OPENGLES") SET(OPENGL_TYPE AUTO CACHE STRING "OpenGL Version; one of: AUTO OPENGL OPENGLES2")
SET_PROPERTY(CACHE OPENGL_TYPE PROPERTY STRINGS "AUTO" "OPENGL" "OPENGLES2")
ENDIF(NOT OPENGL_TYPE)
IF(OPENGL_TYPE STREQUAL "AUTO") IF(NOT OPENGL_TYPE STREQUAL "AUTO" AND NOT OPENGL_TYPE STREQUAL "OPENGL" AND NOT OPENGL_TYPE STREQUAL "OPENGLES2")
IF(OPENGL_FOUND) MESSAGE(FATAL_ERROR "Invalid OPENGL_TYPE setting ${OPENGL_TYPE}; must be one of AUTO OPENGL OPENGLES2")
MESSAGE(STATUS "OpenGL found; using that.") ENDIF(NOT OPENGL_TYPE STREQUAL "AUTO" AND NOT OPENGL_TYPE STREQUAL "OPENGL" AND NOT OPENGL_TYPE STREQUAL "OPENGLES2")
SET(OPENGL_TYPE "OPENGL")
ENDIF(OPENGL_FOUND)
ENDIF(OPENGL_TYPE STREQUAL "AUTO")
IF(OPENGL_TYPE STREQUAL "AUTO") IF(OPENGL_TYPE STREQUAL "AUTO")
IF(OPENGLES_FOUND) IF(OPENGL_FOUND)
MESSAGE(STATUS "OpenGL ES found; using that.") MESSAGE(STATUS "OpenGL found; using that.")
SET(OPENGL_TYPE "OPENGLES") SET(OPENGL_TYPE "OPENGL")
ENDIF(OPENGLES_FOUND) ENDIF(OPENGL_FOUND)
ENDIF(OPENGL_TYPE STREQUAL "AUTO") ENDIF(OPENGL_TYPE STREQUAL "AUTO")
IF(OPENGL_TYPE STREQUAL "AUTO") IF(OPENGL_TYPE STREQUAL "AUTO")
MESSAGE(FATAL_ERROR "OpenGL is required but CMake couldn't find it.") IF(OPENGLES2_FOUND)
ENDIF(OPENGL_TYPE STREQUAL "AUTO") MESSAGE(STATUS "OpenGL ES 2.0 found; using that.")
SET(OPENGL_TYPE "OPENGLES2")
ENDIF(OPENGLES2_FOUND)
ENDIF(OPENGL_TYPE STREQUAL "AUTO")
IF(OPENGL_TYPE STREQUAL "OPENGL") IF(OPENGL_TYPE STREQUAL "AUTO")
IF(NOT OPENGL_FOUND) MESSAGE(FATAL_ERROR "OpenGL is required but CMake couldn't find it.")
MESAGE(FATAL_ERROR "OpenGL was requested but CMake couldn't find it.") ENDIF(OPENGL_TYPE STREQUAL "AUTO")
ENDIF(NOT OPENGL_FOUND)
ENDIF(OPENGL_TYPE STREQUAL "OPENGL")
IF(OPENGL_TYPE STREQUAL "OPENGLES") IF(OPENGL_TYPE STREQUAL "OPENGL")
IF(NOT OPENGLES_FOUND) IF(NOT OPENGL_FOUND)
MESSAGE(FATAL_ERROR "OpenGL ES was requested but CMake couldn't find it.") MESAGE(FATAL_ERROR "OpenGL was requested but CMake couldn't find it.")
ENDIF(NOT OPENGLES_FOUND) ENDIF(NOT OPENGL_FOUND)
ENDIF(OPENGL_TYPE STREQUAL "OPENGLES") ENDIF(OPENGL_TYPE STREQUAL "OPENGL")
# OpenAL IF(OPENGL_TYPE STREQUAL "OPENGLES2")
IF(NOT OPENAL_FOUND) IF(NOT OPENGLES2_FOUND)
MESSAGE(FATAL_ERROR "OpenAL is required but CMake couldn't find it.") MESSAGE(FATAL_ERROR "OpenGL ES 2.0 was requested but CMake couldn't find it.")
ENDIF(NOT OPENAL_FOUND) ENDIF(NOT OPENGLES2_FOUND)
IF(NOT SDL_TYPE STREQUAL "SDL2")
MESSAGE(FATAL_ERROR "OpenGL ES 2.0 support requires SDL2.")
ENDIF(NOT SDL_TYPE STREQUAL "SDL2")
ENDIF(OPENGL_TYPE STREQUAL "OPENGLES2")
# OpenAL
IF(NOT OPENAL_FOUND)
MESSAGE(FATAL_ERROR "OpenAL is required but CMake couldn't find it.")
ENDIF(NOT OPENAL_FOUND)
ENDIF(NOT AVP_WEB)
# required source files # required source files
LIST(APPEND source src/files.c)
LIST(APPEND source src/winapi.c)
LIST(APPEND source src/stubs.c) LIST(APPEND source src/stubs.c)
LIST(APPEND source src/version.c) LIST(APPEND source src/version.c)
LIST(APPEND source src/mathline.c) LIST(APPEND source src/mathline.c)
@ -339,18 +370,31 @@ LIST(APPEND source src/openal.c)
LIST(APPEND source src/cdplayer.c) LIST(APPEND source src/cdplayer.c)
LIST(APPEND source src/menus.c) LIST(APPEND source src/menus.c)
IF(SDL_TYPE STREQUAL "SDL") IF(WIN32)
LIST(APPEND source src/main.c) LIST(APPEND source src/winfiles.c)
ELSE(WIN32)
LIST(APPEND source src/files.c)
LIST(APPEND source src/winapi.c)
ENDIF(WIN32)
# SDL 1.2 on OS X requires this support file IF(AVP_WEB)
IF(APPLE AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin") LIST(APPEND source src/main2.c)
LIST(APPEND source src/sdl12/sdlmain.m) ENDIF(AVP_WEB)
ENDIF(APPLE AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
ENDIF(SDL_TYPE STREQUAL "SDL")
IF(SDL_TYPE STREQUAL "SDL2") IF(NOT AVP_WEB)
LIST(APPEND source src/main2.c) IF(SDL_TYPE STREQUAL "SDL")
ENDIF(SDL_TYPE STREQUAL "SDL2") LIST(APPEND source src/main.c)
# SDL 1.2 on OS X requires this support file
IF(APPLE AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
LIST(APPEND source src/sdl12/sdlmain.m)
ENDIF(APPLE AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
ENDIF(SDL_TYPE STREQUAL "SDL")
IF(SDL_TYPE STREQUAL "SDL2")
LIST(APPEND source src/main2.c)
ENDIF(SDL_TYPE STREQUAL "SDL2")
ENDIF(NOT AVP_WEB)
### build all source as C++ ### build all source as C++
### (not normally used) ### (not normally used)
@ -366,44 +410,56 @@ INCLUDE_DIRECTORIES(${include})
# manually include src/include # manually include src/include
INCLUDE_DIRECTORIES(src/include) INCLUDE_DIRECTORIES(src/include)
ADD_EXECUTABLE(avp ${source}) IF(AVP_WEB)
ADD_DEFINITIONS(-DUSE_OPENGL_ES=1)
# required dependencies ADD_EXECUTABLE(avp ${source})
IF(SDL_TYPE STREQUAL "SDL") ENDIF(AVP_WEB)
INCLUDE_DIRECTORIES(${SDL_INCLUDE_DIR})
ENDIF(SDL_TYPE STREQUAL "SDL")
IF(SDL_TYPE STREQUAL "SDL2") IF(NOT AVP_WEB)
INCLUDE_DIRECTORIES(${SDL2_INCLUDE_DIR}) ADD_EXECUTABLE(avp ${source})
ENDIF(SDL_TYPE STREQUAL "SDL2")
IF(OPENGL_TYPE STREQUAL "OPENGL") # required dependencies
INCLUDE_DIRECTORIES(${OPENGL_INCLUDE_DIR}) IF(WIN32)
ENDIF(OPENGL_TYPE STREQUAL "OPENGL") TARGET_LINK_LIBRARIES(avp winmm)
ENDIF(WIN32)
IF(OPENGL_TYPE STREQUAL "OPENGLES") IF(SDL_TYPE STREQUAL "SDL")
ADD_DEFINITIONS(-DUSE_OPENGL_ES=1) INCLUDE_DIRECTORIES(${SDL_INCLUDE_DIR})
INCLUDE_DIRECTORIES(${OPENGLES_INCLUDE_DIR}) ENDIF(SDL_TYPE STREQUAL "SDL")
INCLUDE_DIRECTORIES(${EGL_INCLUDE_DIR})
ENDIF(OPENGL_TYPE STREQUAL "OPENGLES")
INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIR}) IF(SDL_TYPE STREQUAL "SDL2")
INCLUDE_DIRECTORIES(${SDL2_INCLUDE_DIR})
ENDIF(SDL_TYPE STREQUAL "SDL2")
IF(SDL_TYPE STREQUAL "SDL") IF(OPENGL_TYPE STREQUAL "OPENGL")
TARGET_LINK_LIBRARIES(avp ${SDL_LIBRARY}) INCLUDE_DIRECTORIES(${OPENGL_INCLUDE_DIR})
ENDIF(SDL_TYPE STREQUAL "SDL") ENDIF(OPENGL_TYPE STREQUAL "OPENGL")
IF(SDL_TYPE STREQUAL "SDL2") IF(OPENGL_TYPE STREQUAL "OPENGLES2")
TARGET_LINK_LIBRARIES(avp ${SDL2_LIBRARY}) ADD_DEFINITIONS(-DUSE_OPENGL_ES=1)
ENDIF(SDL_TYPE STREQUAL "SDL2") INCLUDE_DIRECTORIES(${OPENGLES2_INCLUDE_DIR})
INCLUDE_DIRECTORIES(${EGL_INCLUDE_DIR})
ENDIF(OPENGL_TYPE STREQUAL "OPENGLES2")
IF(OPENGL_TYPE STREQUAL "OPENGL") INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIR})
TARGET_LINK_LIBRARIES(avp ${OPENGL_gl_LIBRARY})
ENDIF(OPENGL_TYPE STREQUAL "OPENGL")
IF(OPENGL_TYPE STREQUAL "OPENGLES") IF(SDL_TYPE STREQUAL "SDL")
TARGET_LINK_LIBRARIES(avp ${OPENGLES_gl_LIBRARY}) TARGET_LINK_LIBRARIES(avp ${SDL_LIBRARY})
TARGET_LINK_LIBRARIES(avp ${EGL_LIBRARIES}) ENDIF(SDL_TYPE STREQUAL "SDL")
ENDIF(OPENGL_TYPE STREQUAL "OPENGLES")
TARGET_LINK_LIBRARIES(avp ${OPENAL_LIBRARY}) IF(SDL_TYPE STREQUAL "SDL2")
TARGET_LINK_LIBRARIES(avp ${SDL2_LIBRARY})
ENDIF(SDL_TYPE STREQUAL "SDL2")
IF(OPENGL_TYPE STREQUAL "OPENGL")
TARGET_LINK_LIBRARIES(avp ${OPENGL_gl_LIBRARY})
ENDIF(OPENGL_TYPE STREQUAL "OPENGL")
IF(OPENGL_TYPE STREQUAL "OPENGLES2")
TARGET_LINK_LIBRARIES(avp ${OPENGLES2_gl_LIBRARY})
TARGET_LINK_LIBRARIES(avp ${EGL_LIBRARIES})
ENDIF(OPENGL_TYPE STREQUAL "OPENGLES2")
TARGET_LINK_LIBRARIES(avp ${OPENAL_LIBRARY})
ENDIF(NOT AVP_WEB)

94
FindOpenGLES.cmake
View file

@ -1,94 +0,0 @@
#-------------------------------------------------------------------
# This file is part of the CMake build system for OGRE
# (Object-oriented Graphics Rendering Engine)
# For the latest info, see http://www.ogre3d.org/
#
# The contents of this file are placed in the public domain. Feel
# free to make use of it in any way you like.
#-------------------------------------------------------------------
# - Try to find OpenGLES
# Once done this will define
#
# OPENGLES_FOUND - system has OpenGLES
# OPENGLES_INCLUDE_DIR - the GL include directory
# OPENGLES_LIBRARIES - Link these to use OpenGLES
IF (WIN32)
IF (CYGWIN)
FIND_PATH(OPENGLES_INCLUDE_DIR GLES/gl.h )
FIND_LIBRARY(OPENGLES_gl_LIBRARY libgles_cm )
ELSE (CYGWIN)
IF(BORLAND)
SET (OPENGLES_gl_LIBRARY import32 CACHE STRING "OpenGL ES 1.x library for win32")
ELSE(BORLAND)
#MS compiler - todo - fix the following line:
SET (OPENGLES_gl_LIBRARY ${OGRE_SOURCE_DIR}/Dependencies/lib/release/libgles_cm.lib CACHE STRING "OpenGL ES 1.x library for win32")
ENDIF(BORLAND)
ENDIF (CYGWIN)
ELSE (WIN32)
IF (APPLE)
#create_search_paths(/Developer/Platforms)
#findpkg_framework(OpenGLES)
#set(OPENGLES_gl_LIBRARY "-framework OpenGLES")
ELSE(APPLE)
FIND_PATH(OPENGLES_INCLUDE_DIR GLES/gl.h
/opt/vc/include
/opt/graphics/OpenGL/include
/usr/openwin/share/include
/usr/X11R6/include
/usr/include
)
FIND_LIBRARY(OPENGLES_gl_LIBRARY
NAMES GLES_CM GLESv1_CM
PATHS /opt/vc/lib
/opt/graphics/OpenGL/lib
/usr/openwin/lib
/usr/shlib /usr/X11R6/lib
/usr/lib
)
# On Unix OpenGL most certainly always requires X11.
# Feel free to tighten up these conditions if you don't
# think this is always true.
#IF (OPENGLES_gl_LIBRARY)
# IF(NOT X11_FOUND)
# INCLUDE(FindX11)
# ENDIF(NOT X11_FOUND)
# IF (X11_FOUND)
# SET (OPENGLES_LIBRARIES ${X11_LIBRARIES})
# ENDIF (X11_FOUND)
#ENDIF (OPENGLES_gl_LIBRARY)
ENDIF(APPLE)
ENDIF (WIN32)
SET( OPENGLES_FOUND "NO" )
IF(OPENGLES_gl_LIBRARY)
SET( OPENGLES_LIBRARIES ${OPENGLES_gl_LIBRARY} ${OPENGLES_LIBRARIES})
SET( OPENGLES_FOUND "YES" )
ENDIF(OPENGLES_gl_LIBRARY)
MARK_AS_ADVANCED(
OPENGLES_INCLUDE_DIR
OPENGLES_gl_LIBRARY
)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(OPENGLES REQUIRED_VARS OPENGLES_LIBRARIES OPENGLES_INCLUDE_DIR)

26
src/avp/hmodel.h
View file

@ -56,15 +56,13 @@ I'm going to try storing the quaternions as shorts within the keyframes ,
because there are loads of them. because there are loads of them.
-Richard. -Richard.
*/ */
PACKED_PUSH
typedef struct quat_short typedef struct quat_short
{ {
short quatx; short quatx;
short quaty; short quaty;
short quatz; short quatz;
short quatw; short quatw;
} PACKED QUAT_SHORT; } QUAT_SHORT;
PACKED_POP
/*A couple of conversion functions */ /*A couple of conversion functions */
extern void CopyShortQuatToInt(QUAT_SHORT* qs_from,QUAT* q_to); extern void CopyShortQuatToInt(QUAT_SHORT* qs_from,QUAT* q_to);
@ -74,21 +72,30 @@ extern void CopyIntQuatToShort(QUAT* q_from,QUAT_SHORT* qs_to);
#define KEYFRAME_VECTOR_SHIFT 4 #define KEYFRAME_VECTOR_SHIFT 4
//make sure the keyframe structure packs as much as possible //make sure the keyframe structure packs as much as possible
// packing pragmas removed to fix alignment issues.
PACKED_PUSH
typedef struct keyframe_data { typedef struct keyframe_data {
short Offset_x; /*Offset values may need to be scaled*/ short Offset_x; /*Offset values may need to be scaled*/
short Offset_y; /*In practice scaling should only be needed for 'placed' hierarchies*/ short Offset_y; /*In practice scaling should only be needed for 'placed' hierarchies*/
short Offset_z; short Offset_z;
/* Quats */ /* Quats */
QUAT_SHORT QOrient; QUAT_SHORT QOrient;
/*
These have been moved from the end to here
to reduce padding.
*/
unsigned short Sequence_Length; /* Time between these values and the next ones. */
struct keyframe_data *Next_Frame; /*This is no longer Null for the last frame - look at the last_frame setting instead*/
/* /*
int oneoversinomega; int oneoversinomega;
Removed oneoversinomega , since I can save a far amount of memory by doing so , Removed oneoversinomega , since I can save a far amount of memory by doing so ,
and the value is just calculated using a lookup table anyway. -Richard and the value is just calculated using a lookup table anyway. -Richard
*/ */
int oneoversequencelength; int oneoversequencelength;
unsigned short omega:12; unsigned short omega:12;
/* Quats */ /* Quats */
unsigned short slerp_to_negative_quat:1; /*Should the slerping use the negative version of the next quaternion*/ unsigned short slerp_to_negative_quat:1; /*Should the slerping use the negative version of the next quaternion*/
@ -96,12 +103,7 @@ typedef struct keyframe_data {
unsigned short shift_offset:1; /*does offset need to be scaled*/ unsigned short shift_offset:1; /*does offset need to be scaled*/
unsigned short last_frame:1; /*Is this the last frame?*/ unsigned short last_frame:1; /*Is this the last frame?*/
} KEYFRAME_DATA;
unsigned short Sequence_Length; /* Time between these values and the next ones. */
struct keyframe_data *Next_Frame; /*This is no longer Null for the last frame - look at the last_frame setting instead*/
} PACKED KEYFRAME_DATA;
PACKED_POP
/*Two functions for extracting and setting the key frame offset */ /*Two functions for extracting and setting the key frame offset */
extern void GetKeyFrameOffset(KEYFRAME_DATA* frame,VECTORCH* output_vector); extern void GetKeyFrameOffset(KEYFRAME_DATA* frame,VECTORCH* output_vector);

11
src/avp/scream.cpp
View file

@ -1,3 +1,4 @@
#include "unaligned.h"
#include "3dc.h" #include "3dc.h"
#include "ourasert.h" #include "ourasert.h"
#include "psndplat.h" #include "psndplat.h"
@ -98,9 +99,9 @@ void CharacterSoundEffects::LoadSounds(const char* filename,const char* director
char* bufpos=buffer+8; char* bufpos=buffer+8;
num_voice_types=*(int*)bufpos; num_voice_types=*(unaligned_s32*)bufpos;
bufpos+=4; bufpos+=4;
num_voice_cats=*(int*)bufpos; num_voice_cats=*(unaligned_s32*)bufpos;
bufpos+=4; bufpos+=4;
voice_types=(ScreamVoiceType*) PoolAllocateMem(num_voice_types * sizeof(ScreamVoiceType)); voice_types=(ScreamVoiceType*) PoolAllocateMem(num_voice_types * sizeof(ScreamVoiceType));
@ -116,7 +117,7 @@ void CharacterSoundEffects::LoadSounds(const char* filename,const char* director
{ {
ScreamSoundCategory* cat=&voice_types[i].category[j]; ScreamSoundCategory* cat=&voice_types[i].category[j];
cat->last_sound=SID_NOSOUND; cat->last_sound=SID_NOSOUND;
cat->num_sounds=*(int*)bufpos; cat->num_sounds=*(unaligned_s32*)bufpos;
bufpos+=4; bufpos+=4;
if(cat->num_sounds) if(cat->num_sounds)
@ -135,9 +136,9 @@ void CharacterSoundEffects::LoadSounds(const char* filename,const char* director
strcpy(wavname,bufpos); strcpy(wavname,bufpos);
bufpos+=strlen(bufpos)+1; bufpos+=strlen(bufpos)+1;
sound->pitch=*(int*)bufpos; sound->pitch=*(unaligned_s32*)bufpos;
bufpos+=4; bufpos+=4;
sound->volume=*(int*)bufpos; sound->volume=*(unaligned_s32*)bufpos;
bufpos+=4; bufpos+=4;
sound->sound_loaded=GetSound(wavpath); sound->sound_loaded=GetSound(wavpath);

14
src/avp/stratdef.h
View file

@ -1,6 +1,8 @@
#ifndef _stratdef_h_ #ifndef _stratdef_h_
#define _stratdef_h_ 1 #define _stratdef_h_ 1
#include "unaligned.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -277,17 +279,17 @@ extern STRATEGYBLOCK *ActiveStBlockList[];
#define COPY_NAME(name1, name2) \ #define COPY_NAME(name1, name2) \
{ \ { \
GLOBALASSERT(SB_NAME_LENGTH == 8); \ GLOBALASSERT(SB_NAME_LENGTH == 8); \
*(int*)name1 = *(int*)name2; \ *(unaligned_s32*)name1 = *(unaligned_s32*)name2; \
*((int*)name1 + 1) = *((int*)name2 + 1);\ *((unaligned_s32*)name1 + 1) = *((unaligned_s32*)name2 + 1);\
} }
#define NAME_ISEQUAL(name1, name2) \ #define NAME_ISEQUAL(name1, name2) \
((*(int*)name1 == *(int*)name2) && \ ((*(unaligned_s32*)name1 == *(unaligned_s32*)name2) && \
(*(((int*)name1) + 1) == *(((int*)name2) + 1))) (*(((unaligned_s32*)name1) + 1) == *(((unaligned_s32*)name2) + 1)))
#define NAME_ISNULL(name1) \ #define NAME_ISNULL(name1) \
((*(int*)name1 == '\0') && \ ((*(unaligned_s32*)name1 == '\0') && \
(*(((int*)name1) + 1) == '\0')) (*(((unaligned_s32*)name1) + 1) == '\0'))
#ifdef __cplusplus #ifdef __cplusplus

156
src/avp/win95/frontend/avp_menus.c
View file

@ -227,6 +227,162 @@ static const char* MultiplayerConfigurationName=0; //ditto
extern int DebuggingCommandsActive; extern int DebuggingCommandsActive;
int AvP_MainMenus_Init(void)
{
#if 0
SaveDefaultPrimaryConfigs();
#else
LoadDefaultPrimaryConfigs();
#endif
SoundSys_ResetFadeLevel();
SoundSys_Management();
TimeScale = ONE_FIXED;
if (!LobbiedGame) // Edmond
CheckForCredits();
TimeStampedMessage("start of menus");
// open a 640x480x16 screen
SelectMenuDisplayMode();
TimeStampedMessage("after SelectMenuDisplayMode");
InitialiseMenuGfx();
TimeStampedMessage("after InitialiseMenuGfx");
// inform backdrop code
InitMainMenusBackdrop();
TimeStampedMessage("after InitMainMenusBackdrop");
#if PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO
if (AvP.LevelCompleted)
{
Show_WinnerScreen();
}
#endif
LoadAllAvPMenuGfx();
TimeStampedMessage("after LoadAllAvPMenuGfx");
ResetFrameCounter();
if (!LobbiedGame) // Edmond
PlayIntroSequence();
if (VideoModeNotAvailable)
{
LoadGameRequest = SAVELOAD_REQUEST_NONE;
DisplayVideoModeUnavailableScreen();
}
VideoModeNotAvailable = 0;
if(AvP.LevelCompleted && CheatMode_Active == CHEATMODE_NONACTIVE && !DebuggingCommandsActive)
{
HandlePostGameFMVs();
OkayToPlayNextEpisode();
AvP.LevelCompleted = 0;
AvPMenus.MenusState = MENUSSTATE_MAINMENUS;
}
else if(!LobbiedGame)
{
if (UserProfileNumber==-1)
{
SetupNewMenu(AVPMENU_USERPROFILESELECT);
}
else
{
SetupNewMenu(AVPMENU_MAIN);
}
AvPMenus.MenusState = MENUSSTATE_MAINMENUS;
}
else
{
SetupNewMenu(AVPMENU_USERPROFILESELECT);
//AvPMenus.MenusState = MENUSSTATE_STARTGAME;
}
CheatMode_Active = CHEATMODE_NONACTIVE;
TimeStampedMessage("starting general menus");
return 0;
}
int AvP_MainMenus_Update(void) {
CheckForWindowsMessages();
DrawMainMenusBackdrop();
ReadUserInput();
AvP_UpdateMenus();
// BezierCurve();
ShowMenuFrameRate();
FlipBuffers();
FrameCounterHandler();
PlayMenuMusic();
#if 0
{
extern int EffectsSoundVolume;
SoundSys_ChangeVolume(EffectsSoundVolume);
}
#endif
SoundSys_Management();
UpdateGammaSettings();
CheckForLoadGame();
return AvPMenus.MenusState == MENUSSTATE_MAINMENUS;
}
int AvP_MainMenus_Deinit(void) {
if (AvPMenus.MenusState==MENUSSTATE_OUTSIDEMENUS)
{
//Don't bother showing credits if we are just exiting in order to start a game
//using mplayer. The credits will get shown later after the player has actually
//played the game
if(!LaunchingMplayer)
{
if (!LobbiedGame) // Edmond
DoCredits();
}
}
TimeStampedMessage("ready to exit menus");
EndMenuMusic();
EndMenuBackgroundBink();
TimeStampedMessage("after EndMenuMusic");
#if PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO
if ((AvPMenus.MenusState != MENUSSTATE_STARTGAME)) ShowSplashScreens();
TimeStampedMessage("after ShowSplashScreens");
#endif
ReleaseAllAvPMenuGfx();
TimeStampedMessage("after ReleaseAllAvPMenuGfx");
SoundSys_StopAll();
SoundSys_Management();
if (CheatMode_Active == CHEATMODE_NONACTIVE) HandlePreGameFMVs();
HandleCheatModeFeatures();
AvP.LevelCompleted = 0;
return (AvPMenus.MenusState == MENUSSTATE_STARTGAME);
}
int AvP_MainMenus(void) int AvP_MainMenus(void)
{ {
#if 0 #if 0

5
src/avp/win95/progress_bar.cpp
View file

@ -228,7 +228,8 @@ void Game_Has_Loaded(void)
int f = 65536; int f = 65536;
ResetFrameCounter(); ResetFrameCounter();
do #warning Game_Has_Loaded commented out a blocking loop
//do
{ {
CheckForWindowsMessages(); CheckForWindowsMessages();
ReadUserInput(); ReadUserInput();
@ -284,7 +285,7 @@ void Game_Has_Loaded(void)
} }
} }
while(!DebouncedGotAnyKey); // while(!DebouncedGotAnyKey);
FadingGameInAfterLoading=ONE_FIXED; FadingGameInAfterLoading=ONE_FIXED;

2
src/fixer.h
View file

@ -76,6 +76,8 @@ extern "C" {
#define _snprintf snprintf #define _snprintf snprintf
#define __inline inline
size_t _mbclen(const unsigned char *s); size_t _mbclen(const unsigned char *s);
#define RGBA_MAKE(r, g, b, a) ((((a) << 24) | ((r) << 16) | ((g) << 8) | (b))) #define RGBA_MAKE(r, g, b, a) ((((a) << 24) | ((r) << 16) | ((g) << 8) | (b)))

16
src/fmv.c
View file

@ -288,7 +288,7 @@ void SetupFMVTexture(FMVTEXTURE *ftPtr)
{ {
if (ftPtr->PalettedBuf == NULL) if (ftPtr->PalettedBuf == NULL)
{ {
ftPtr->PalettedBuf = (unsigned char*) malloc(128*128*4); ftPtr->PalettedBuf = (unsigned char*) calloc(1, 128*128+128*128*4);
} }
if (ftPtr->RGBBuf == NULL) if (ftPtr->RGBBuf == NULL)
@ -300,6 +300,10 @@ void SetupFMVTexture(FMVTEXTURE *ftPtr)
ftPtr->RGBBuf = &ftPtr->PalettedBuf[128*128]; ftPtr->RGBBuf = &ftPtr->PalettedBuf[128*128];
} }
pglBindTexture(GL_TEXTURE_2D, ftPtr->ImagePtr->D3DTexture->id);
pglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, &ftPtr->RGBBuf[0]);
} }
void UpdateFMVTexture(FMVTEXTURE *ftPtr) void UpdateFMVTexture(FMVTEXTURE *ftPtr)
@ -327,16 +331,20 @@ void UpdateFMVTexture(FMVTEXTURE *ftPtr)
unsigned char source = (*srcPtr++); unsigned char source = (*srcPtr++);
dstPtr[0] = ftPtr->SrcPalette[source].peRed; dstPtr[0] = ftPtr->SrcPalette[source].peRed;
dstPtr[1] = ftPtr->SrcPalette[source].peGreen; dstPtr[1] = ftPtr->SrcPalette[source].peGreen;
dstPtr[2] = ftPtr->SrcPalette[source].peBlue; dstPtr[2] = ftPtr->SrcPalette[source].peBlue;
dstPtr[3] = 255;
dstPtr += 3; dstPtr += 4;
} while(--pixels); } while(--pixels);
//#warning move this into opengl.c //#warning move this into opengl.c
// update the opengl texture // update the opengl texture
pglBindTexture(GL_TEXTURE_2D, ftPtr->ImagePtr->D3DTexture->id); pglBindTexture(GL_TEXTURE_2D, ftPtr->ImagePtr->D3DTexture->id);
pglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 128, 96, GL_RGB, GL_UNSIGNED_BYTE, &ftPtr->RGBBuf[0]); pglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 128, 96, GL_RGBA, GL_UNSIGNED_BYTE, &ftPtr->RGBBuf[0]);
// if using mipmaps, they will need to be updated now
//pglGenerateMipmap(GL_TEXTURE_2D);
} }
void ReleaseFMVTexture(FMVTEXTURE *ftPtr) void ReleaseFMVTexture(FMVTEXTURE *ftPtr)

4
src/main.c
View file

@ -620,8 +620,6 @@ int SetOGLVideoMode(int Width, int Height)
pglDepthFunc(GL_LEQUAL); pglDepthFunc(GL_LEQUAL);
pglDepthMask(GL_TRUE); pglDepthMask(GL_TRUE);
pglDepthRange(0.0, 1.0); pglDepthRange(0.0, 1.0);
pglEnable(GL_TEXTURE_2D);
pglDisable(GL_CULL_FACE); pglDisable(GL_CULL_FACE);
@ -640,7 +638,7 @@ int SetOGLVideoMode(int Width, int Height)
load_ogl_functions(1); load_ogl_functions(1);
InitOpenGL(); InitOpenGL(1);
return 0; return 0;
} }

470
src/main2.c
View file

@ -45,6 +45,9 @@
#include "version.h" #include "version.h"
#include "fmv.h" #include "fmv.h"
#if EMSCRIPTEN
#include <emscripten.h>
#endif
#if defined(__IPHONEOS__) || defined(__ANDROID__) #if defined(__IPHONEOS__) || defined(__ANDROID__)
#define FIXED_WINDOW_SIZE 1 #define FIXED_WINDOW_SIZE 1
@ -54,6 +57,13 @@
#define USE_OPENGL_ES 1 #define USE_OPENGL_ES 1
#endif #endif
#warning WINDOW_SIZE_DEBUG is on in all builds
#if 1 //!defined(NDEBUG)
#define WINDOW_SIZE_DEBUG
#endif
static void main_loop(void);
void RE_ENTRANT_QUEUE_WinProc_AddMessage_WM_CHAR(char Ch); void RE_ENTRANT_QUEUE_WinProc_AddMessage_WM_CHAR(char Ch);
void RE_ENTRANT_QUEUE_WinProc_AddMessage_WM_KEYDOWN(int wParam); void RE_ENTRANT_QUEUE_WinProc_AddMessage_WM_KEYDOWN(int wParam);
@ -83,11 +93,15 @@ SDL_Joystick *joy;
JOYINFOEX JoystickData; JOYINFOEX JoystickData;
JOYCAPS JoystickCaps; JOYCAPS JoystickCaps;
static int main_loop_state = 0;
// Window configuration and state // Window configuration and state
static int WindowWidth; static int WindowWidth;
static int WindowHeight; static int WindowHeight;
static int ViewportWidth; static int ViewportWidth;
static int ViewportHeight; static int ViewportHeight;
static int DrawableWidth;
static int DrawableHeight;
enum RENDERING_MODE { enum RENDERING_MODE {
RENDERING_MODE_SOFTWARE, RENDERING_MODE_SOFTWARE,
@ -111,12 +125,21 @@ static int WantMouseGrab = 0;
// Additional configuration // Additional configuration
int WantSound = 1; int WantSound = 1;
static int WantCDRom = 0; static int WantCDRom = 0;
static int WantJoystick = 0; static int WantJoystick = 1;
static GLuint FullscreenTexture; static GLuint FullscreenTexture;
static GLsizei FullscreenTextureWidth; static GLsizei FullscreenTextureWidth;
static GLsizei FullscreenTextureHeight; static GLsizei FullscreenTextureHeight;
static GLuint FullscreenArrayBuffer;
static GLuint FullscreenElementArrayBuffer;
static GLuint FramebufferTexture;
static GLsizei FramebufferTextureWidth;
static GLsizei FramebufferTextureHeight;
static GLuint FramebufferObject;
static GLuint FramebufferDepthObject;
/* originally was "/usr/lib/libGL.so.1:/usr/lib/tls/libGL.so.1:/usr/X11R6/lib/libGL.so" */ /* originally was "/usr/lib/libGL.so.1:/usr/lib/tls/libGL.so.1:/usr/X11R6/lib/libGL.so" */
static const char * opengl_library = NULL; static const char * opengl_library = NULL;
@ -213,14 +236,14 @@ unsigned char *GetScreenShot24(int *width, int *height)
} }
if (RenderingMode == RENDERING_MODE_OPENGL) { if (RenderingMode == RENDERING_MODE_OPENGL) {
buf = (unsigned char *)malloc(ViewportWidth * ViewportHeight * 3); buf = (unsigned char *)malloc(DrawableWidth * DrawableHeight * 3);
*width = ViewportWidth; *width = DrawableWidth;
*height = ViewportHeight; *height = DrawableHeight;
pglPixelStorei(GL_PACK_ALIGNMENT, 1); pglPixelStorei(GL_PACK_ALIGNMENT, 1);
pglPixelStorei(GL_UNPACK_ALIGNMENT, 1); pglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
pglReadPixels(0, 0, ViewportWidth, ViewportHeight, GL_RGB, GL_UNSIGNED_BYTE, buf); pglReadPixels(0, 0, DrawableWidth, DrawableHeight, GL_RGB, GL_UNSIGNED_BYTE, buf);
} else { } else {
buf = (unsigned char *)malloc(surface->w * surface->h * 3); buf = (unsigned char *)malloc(surface->w * surface->h * 3);
@ -415,6 +438,11 @@ char *GetVideoModeDescription3()
int InitSDL() int InitSDL()
{ {
#if EMSCRIPTEN
printf("Setting main loop...\n");
emscripten_set_main_loop(main_loop, 0, 0);
#endif
if (SDL_Init(SDL_INIT_VIDEO) < 0) { if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "SDL Init failed: %s\n", SDL_GetError()); fprintf(stderr, "SDL Init failed: %s\n", SDL_GetError());
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
@ -531,7 +559,7 @@ int InitSDL()
return 0; return 0;
} }
#if !defined(NDEBUG) #if defined(WINDOW_SIZE_DEBUG)
static void DumpVideoModeInfo(SDL_Window* w) { static void DumpVideoModeInfo(SDL_Window* w) {
int numVideoDisplays; int numVideoDisplays;
int displayIndex; int displayIndex;
@ -599,18 +627,27 @@ static void DumpVideoModeInfo(SDL_Window* w) {
mode.h, mode.h,
mode.refresh_rate); mode.refresh_rate);
} }
int width, height;
SDL_GetWindowSize(w, &width, &height);
printf("Window size: %4d,%4d\n", width, height);
SDL_GL_GetDrawableSize(w, &width, &height);
printf("Window drawable size: %4d,%4d\n", width, height);
} }
} }
#endif #endif
static void SetWindowSize(int PhysicalWidth, int PhysicalHeight, int VirtualWidth, int VirtualHeight) static void SetWindowSize(int PhysicalWidth, int PhysicalHeight, int VirtualWidth, int VirtualHeight)
{ {
#if !defined(NDEBUG) #if defined(WINDOW_SIZE_DEBUG)
fprintf(stderr, "SetWindowSize(%d,%d,%d,%d); %d\n", PhysicalWidth, PhysicalHeight, VirtualWidth, VirtualHeight, CurrentVideoMode); printf("SetWindowSize(%d,%d,%d,%d); %d\n", PhysicalWidth, PhysicalHeight, VirtualWidth, VirtualHeight, CurrentVideoMode);
#endif #endif
ViewportWidth = PhysicalWidth; ViewportWidth = PhysicalWidth;
ViewportHeight = PhysicalHeight; ViewportHeight = PhysicalHeight;
DrawableWidth = ViewportWidth;
DrawableHeight = ViewportHeight;
ScreenDescriptorBlock.SDB_Width = VirtualWidth; ScreenDescriptorBlock.SDB_Width = VirtualWidth;
ScreenDescriptorBlock.SDB_Height = VirtualHeight; ScreenDescriptorBlock.SDB_Height = VirtualHeight;
@ -626,10 +663,11 @@ static void SetWindowSize(int PhysicalWidth, int PhysicalHeight, int VirtualWidt
if (window != NULL) { if (window != NULL) {
SDL_SetWindowSize(window, PhysicalWidth, PhysicalHeight); SDL_SetWindowSize(window, PhysicalWidth, PhysicalHeight);
//pglViewport(0, 0, ViewportWidth, ViewportHeight); SDL_GL_GetDrawableSize(window, &DrawableWidth, &DrawableHeight);
pglViewport(0, 0, DrawableWidth, DrawableHeight);
} }
#if !defined(NDEBUG) #if defined(WINDOW_SIZE_DEBUG)
DumpVideoModeInfo(window); DumpVideoModeInfo(window);
#endif #endif
} }
@ -708,6 +746,8 @@ static int InitSDLVideo(void) {
static int SetOGLVideoMode(int Width, int Height) static int SetOGLVideoMode(int Width, int Height)
{ {
GLenum status;
int firsttime = 0;
int oldflags; int oldflags;
int flags; int flags;
@ -725,9 +765,11 @@ static int SetOGLVideoMode(int Width, int Height)
#endif #endif
if (window == NULL) { if (window == NULL) {
firsttime = 1;
load_ogl_functions(0); load_ogl_functions(0);
flags = SDL_WINDOW_OPENGL; flags = SDL_WINDOW_OPENGL|SDL_WINDOW_ALLOW_HIGHDPI;
#if defined(FIXED_WINDOW_SIZE) #if defined(FIXED_WINDOW_SIZE)
flags |= SDL_WINDOW_BORDERLESS; flags |= SDL_WINDOW_BORDERLESS;
@ -751,8 +793,8 @@ static int SetOGLVideoMode(int Width, int Height)
// set OpenGL attributes first // set OpenGL attributes first
#if defined(USE_OPENGL_ES) #if defined(USE_OPENGL_ES)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES); SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#else #else
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
@ -795,7 +837,10 @@ static int SetOGLVideoMode(int Width, int Height)
load_ogl_functions(1); load_ogl_functions(1);
SDL_GetWindowSize(window, &Width, &Height); SDL_GL_GetDrawableSize(window, &Width, &Height);
#if defined(WINDOW_SIZE_DEBUG)
printf("glViewport(0, 0, %d, %d)\n", Width, Height);
#endif
pglViewport(0, 0, Width, Height); pglViewport(0, 0, Width, Height);
// create fullscreen window texture // create fullscreen window texture
@ -808,17 +853,79 @@ static int SetOGLVideoMode(int Width, int Height)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
FullscreenTextureWidth = 1024; FullscreenTextureWidth = 640;
FullscreenTextureHeight = 512; FullscreenTextureHeight = 480;
pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, FullscreenTextureWidth, FullscreenTextureHeight, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL); pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, FullscreenTextureWidth, FullscreenTextureHeight, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
// this should be deleted and rebuilt when the screen size changes
GLint maxRenderbufferSize;
GLint maxTextureSize;
GLint maxViewportDims;
GLint maxRenderSize;
pglGetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &maxRenderbufferSize);
pglGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
pglGetIntegerv(GL_MAX_VIEWPORT_DIMS, &maxViewportDims);
printf("DEBUG:%d,%d,%d\n", maxRenderbufferSize, maxTextureSize, maxViewportDims);
FramebufferTextureWidth = Width * 2;
FramebufferTextureHeight = Height * 2;
printf("DEBUG2:%d,%d\n", FramebufferTextureWidth, FramebufferTextureHeight);
maxRenderSize = maxRenderbufferSize;
if (maxRenderSize > maxTextureSize) {
maxRenderSize = maxTextureSize;
}
if (maxRenderSize > maxViewportDims) {
maxRenderSize = maxViewportDims;
}
if (FramebufferTextureWidth > maxRenderSize) {
FramebufferTextureWidth = maxRenderSize;
}
if (FramebufferTextureHeight > maxRenderSize) {
FramebufferTextureHeight = maxRenderSize;
}
printf("DEBUG3:%d,%d\n", FramebufferTextureWidth, FramebufferTextureHeight);
pglGenTextures(1, &FramebufferTexture);
pglGenFramebuffers(1, &FramebufferObject);
pglGenRenderbuffers(1, &FramebufferDepthObject);
pglBindTexture(GL_TEXTURE_2D, FramebufferTexture);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, FramebufferTextureWidth, FramebufferTextureHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
pglBindTexture(GL_TEXTURE_2D, 0);
pglBindFramebuffer(GL_FRAMEBUFFER, FramebufferObject);
pglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, FramebufferTexture, 0);
pglBindRenderbuffer(GL_RENDERBUFFER, FramebufferDepthObject);
pglRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, FramebufferTextureWidth, FramebufferTextureHeight);
pglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, FramebufferDepthObject);
pglGenBuffers(1, &FullscreenArrayBuffer);
pglGenBuffers(1, &FullscreenElementArrayBuffer);
check_for_errors();
status = pglCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
fprintf(stderr, "Incomplete framebuffer, status:%04x\n", status);
}
pglBindFramebuffer(GL_FRAMEBUFFER, 0);
pglBindRenderbuffer(GL_RENDERBUFFER, 0);
} }
SDL_GetWindowSize(window, &Width, &Height); SDL_GetWindowSize(window, &Width, &Height);
SetWindowSize(Width, Height, Width, Height); SetWindowSize(Width, Height, Width, Height);
int NewWidth, NewHeight; int NewWidth, NewHeight;
SDL_GetWindowSize(window, &Width, &Height); SDL_GetWindowSize(window, &NewWidth, &NewHeight);
if (Width != NewWidth || Height != NewHeight) { if (Width != NewWidth || Height != NewHeight) {
//printf("Failed to change size: %d,%d vs. %d,%d\n", Width, Height, NewWidth, NewHeight); //printf("Failed to change size: %d,%d vs. %d,%d\n", Width, Height, NewWidth, NewHeight);
//Width = NewWidth; //Width = NewWidth;
@ -833,15 +940,15 @@ static int SetOGLVideoMode(int Width, int Height)
pglDepthFunc(GL_LEQUAL); pglDepthFunc(GL_LEQUAL);
pglDepthMask(GL_TRUE); pglDepthMask(GL_TRUE);
pglDepthRange(0.0, 1.0); pglDepthRange(0.0, 1.0);
pglEnable(GL_TEXTURE_2D);
pglDisable(GL_CULL_FACE); pglDisable(GL_CULL_FACE);
pglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); pglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
InitOpenGL(); InitOpenGL(firsttime);
check_for_errors();
return 0; return 0;
} }
@ -861,6 +968,16 @@ int ExitWindowsSystem()
} }
FullscreenTexture = 0; FullscreenTexture = 0;
if (FullscreenArrayBuffer != 0) {
pglDeleteBuffers(1, &FullscreenArrayBuffer);
}
FullscreenArrayBuffer = 0;
if (FullscreenElementArrayBuffer != 0) {
pglDeleteBuffers(1, &FullscreenElementArrayBuffer);
}
FullscreenElementArrayBuffer = 0;
load_ogl_functions(0); load_ogl_functions(0);
if (surface != NULL) { if (surface != NULL) {
@ -1224,7 +1341,9 @@ void CheckForWindowsMessages()
// disable mouse grab? // disable mouse grab?
break; break;
case SDL_WINDOWEVENT_RESIZED: case SDL_WINDOWEVENT_RESIZED:
//printf("test, %d,%d\n", event.window.data1, event.window.data2); #if defined(WINDOW_SIZE_DEBUG)
printf("Window Resized %d,%d\n", event.window.data1, event.window.data2);
#endif
WindowWidth = event.window.data1; WindowWidth = event.window.data1;
WindowHeight = event.window.data2; WindowHeight = event.window.data2;
if (RenderingMode == RENDERING_MODE_SOFTWARE) { if (RenderingMode == RENDERING_MODE_SOFTWARE) {
@ -1233,6 +1352,7 @@ void CheckForWindowsMessages()
SetWindowSize(WindowWidth, WindowHeight, WindowWidth, WindowHeight); SetWindowSize(WindowWidth, WindowHeight, WindowWidth, WindowHeight);
} }
if (pglViewport != NULL) { if (pglViewport != NULL) {
SDL_GL_GetDrawableSize(window, &WindowWidth, &WindowHeight);
pglViewport(0, 0, WindowWidth, WindowHeight); pglViewport(0, 0, WindowWidth, WindowHeight);
} }
break; break;
@ -1342,25 +1462,43 @@ void CheckForWindowsMessages()
void InGameFlipBuffers() void InGameFlipBuffers()
{ {
#if !defined(NDEBUG)
check_for_errors();
#endif
pglBindFramebuffer(GL_FRAMEBUFFER, 0);
pglBindRenderbuffer(GL_RENDERBUFFER, 0);
pglViewport(0, 0, DrawableWidth, DrawableHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
DrawFullscreenTexture(FramebufferTexture);
#if !defined(NDEBUG) #if !defined(NDEBUG)
check_for_errors(); check_for_errors();
#endif #endif
SDL_GL_SwapWindow(window); SDL_GL_SwapWindow(window);
pglBindFramebuffer(GL_FRAMEBUFFER, FramebufferObject);
pglBindRenderbuffer(GL_RENDERBUFFER, FramebufferDepthObject);
pglViewport(0, 0, FramebufferTextureWidth, FramebufferTextureHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
} }
void FlipBuffers() void FlipBuffers()
{ {
pglBindFramebuffer(GL_FRAMEBUFFER, 0);
pglBindRenderbuffer(GL_RENDERBUFFER, 0);
pglViewport(0, 0, DrawableWidth, DrawableHeight);
pglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); pglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
pglDisable(GL_ALPHA_TEST);
pglDisable(GL_BLEND); pglDisable(GL_BLEND);
pglDisable(GL_DEPTH_TEST); pglDisable(GL_DEPTH_TEST);
pglBindTexture(GL_TEXTURE_2D, FullscreenTexture); pglBindTexture(GL_TEXTURE_2D, FullscreenTexture);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
pglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 640, 480, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, surface->pixels); pglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 640, 480, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, surface->pixels);
GLfloat x0; GLfloat x0;
@ -1373,22 +1511,22 @@ void FlipBuffers()
GLfloat t1; GLfloat t1;
// figure out the best way to fit the 640x480 virtual window // figure out the best way to fit the 640x480 virtual window
GLfloat a = ViewportHeight * 640.0f / 480.0f; GLfloat a = DrawableHeight * 640.0f / 480.0f;
GLfloat b = ViewportWidth * 480.0f / 640.0f; GLfloat b = DrawableWidth * 480.0f / 640.0f;
if (a <= ViewportWidth) { if (a <= DrawableWidth) {
// a x ViewportHeight window // a x DrawableHeight window
y0 = -1.0f; y0 = -1.0f;
y1 = 1.0f; y1 = 1.0f;
x1 = 1.0 - (ViewportWidth - a) / ViewportWidth; x1 = 1.0 - (DrawableWidth - a) / DrawableWidth;
x0 = -x1; x0 = -x1;
} else { } else {
// ViewportWidth x b window // DrawableWidth x b window
x0 = -1.0f; x0 = -1.0f;
x1 = 1.0f; x1 = 1.0f;
y1 = 1.0 - (ViewportHeight - b) / ViewportHeight; y1 = 1.0 - (DrawableHeight - b) / DrawableHeight;
y0 = -y1; y0 = -y1;
} }
@ -1424,16 +1562,18 @@ void FlipBuffers()
s[4] = 2; s[4] = 2;
s[5] = 3; s[5] = 3;
pglEnableClientState(GL_VERTEX_ARRAY); SelectProgram(AVP_SHADER_PROGRAM_NO_COLOR_NO_DISCARD);
pglVertexPointer(2, GL_FLOAT, sizeof(GLfloat) * 4, &v[0]);
pglEnableClientState(GL_TEXTURE_COORD_ARRAY); // slow webgl compatibility changes
pglTexCoordPointer(2, GL_FLOAT, sizeof(GLfloat) * 4, &v[2]); pglBindBuffer(GL_ARRAY_BUFFER, FullscreenArrayBuffer);
pglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, FullscreenElementArrayBuffer);
pglBufferData(GL_ARRAY_BUFFER, sizeof(v), v, GL_STREAM_DRAW);
pglBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(s), s, GL_STREAM_DRAW);
pglDisableClientState(GL_COLOR_ARRAY); pglVertexAttribPointer(OPENGL_VERTEX_ATTRIB_INDEX, 2, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), (const GLvoid*) 0);
pglVertexAttribPointer(OPENGL_TEXCOORD_ATTRIB_INDEX, 2, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), (const GLvoid*) 8);
pglColor4f(1.0f, 1.0f, 1.0f, 1.0f); pglDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (const GLvoid*) 0);
pglDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, s);
pglBindTexture(GL_TEXTURE_2D, 0); pglBindTexture(GL_TEXTURE_2D, 0);
@ -1478,6 +1618,10 @@ static const char *usage_string =
" [-j | --nojoy] Do not access the joystick\n" " [-j | --nojoy] Do not access the joystick\n"
" [-g | --withgl] [x] Use [x] instead of /usr/lib/libGL.so.1 for OpenGL\n" " [-g | --withgl] [x] Use [x] instead of /usr/lib/libGL.so.1 for OpenGL\n"
; ;
static int menusActive = 0;
static int thisLevelHasBeenCompleted = 0;
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
@ -1534,7 +1678,7 @@ int main(int argc, char *argv[])
LoadCDTrackList(); LoadCDTrackList();
SetFastRandom(); SetFastRandom();
#if MARINE_DEMO #if MARINE_DEMO
ffInit("fastfile/mffinfo.txt","fastfile/"); ffInit("fastfile/mffinfo.txt","fastfile/");
#elif ALIEN_DEMO #elif ALIEN_DEMO
@ -1553,7 +1697,7 @@ int main(int argc, char *argv[])
/* Env_List can probably be removed */ /* Env_List can probably be removed */
Env_List[0]->main = LevelName; Env_List[0]->main = LevelName;
InitialiseSystem(); InitialiseSystem();
InitialiseRenderer(); InitialiseRenderer();
@ -1584,14 +1728,18 @@ int main(int argc, char *argv[])
SetLevelToLoad(AVP_ENVIRONMENT_INVASION); SetLevelToLoad(AVP_ENVIRONMENT_INVASION);
#endif #endif
main_loop_state = 1;
return 0;
#if 0
#if !(ALIEN_DEMO|PREDATOR_DEMO|MARINE_DEMO) #if !(ALIEN_DEMO|PREDATOR_DEMO|MARINE_DEMO)
while (AvP_MainMenus()) while (AvP_MainMenus())
#else #else
if (AvP_MainMenus()) if (AvP_MainMenus())
#endif #endif
{ {
int menusActive = 0; menusActive = 0;
int thisLevelHasBeenCompleted = 0; thisLevelHasBeenCompleted = 0;
/* turn off any special effects */ /* turn off any special effects */
d3d_light_ctrl.ctrl = LCCM_NORMAL; d3d_light_ctrl.ctrl = LCCM_NORMAL;
@ -1742,9 +1890,10 @@ if (AvP_MainMenus())
/* go back to menu mode */ /* go back to menu mode */
#if !(ALIEN_DEMO|PREDATOR_DEMO|MARINE_DEMO) #if !(ALIEN_DEMO|PREDATOR_DEMO|MARINE_DEMO)
SetSoftVideoMode(640, 480, 16); SetSoftVideoMode(640, 480, 16);
#endif #endif
} }
#if !EMSCRIPTEN
SoundSys_StopAll(); SoundSys_StopAll();
SoundSys_RemoveAll(); SoundSys_RemoveAll();
@ -1752,6 +1901,241 @@ if (AvP_MainMenus())
CDDA_End(); CDDA_End();
ClearMemoryPool(); ClearMemoryPool();
#endif
#endif
return 0;
}
int AvP_MainMenus_Init(void);
int AvP_MainMenus_Update(void);
int AvP_MainMenus_Deinit(void);
static int MainGame_Init(void);
static int MainGame_Update(void);
static int MainGame_Deinit(void);
static void main_loop(void) {
switch (main_loop_state) {
case 0:
return;
case -1:
printf("You can't exit the game!\n");
main_loop_state = 0;
return;
case -999:
printf("Unimplemented!\n");
main_loop_state = 0;
return;
case 1:
AvP_MainMenus_Init();
main_loop_state = 2;
// fallthrough
case 2: {
int cont = AvP_MainMenus_Update();
if (cont != 0) {
return;
}
}
// fallthrough
case 3: {
int cont = AvP_MainMenus_Deinit();
if (cont != 0) {
main_loop_state = 4;
return;
}
}
main_loop_state = -1;
return;
case 4: {
MainGame_Init();
main_loop_state = 5;
// fallthrough
}
case 5: {
int cont = MainGame_Update();
if (cont != 0) {
return;
}
// fallthrough
}
case 6: {
MainGame_Deinit();
main_loop_state = 1;
}
}
}
static int MainGame_Init(void) {
menusActive = 0;
thisLevelHasBeenCompleted = 0;
/* turn off any special effects */
d3d_light_ctrl.ctrl = LCCM_NORMAL;
SetOGLVideoMode(0, 0);
InitialiseGammaSettings(RequestedGammaSetting);
start_of_loaded_shapes = load_precompiled_shapes();
InitCharacter();
LoadRifFile(); /* sets up a map */
AssignAllSBNames();
StartGame();
ffcloseall();
AvP.MainLoopRunning = 1;
ScanImagesForFMVs();
ResetFrameCounter();
Game_Has_Loaded();
ResetFrameCounter();
if(AvP.Network!=I_No_Network)
{
/*Need to choose a starting position for the player , but first we must look
through the network messages to find out which generator spots are currently clear*/
netGameData.myGameState = NGS_Playing;
MinimalNetCollectMessages();
TeleportNetPlayerToAStartingPosition(Player->ObStrategyBlock,1);
}
IngameKeyboardInput_ClearBuffer();
return 0;
}
static int MainGame_Update(void) {
if(AvP.MainLoopRunning) {
CheckForWindowsMessages();
switch(AvP.GameMode) {
case I_GM_Playing:
if ((!menusActive || (AvP.Network!=I_No_Network && !netGameData.skirmishMode)) && !AvP.LevelCompleted) {
/* TODO: print some debugging stuff */
DoAllShapeAnimations();
UpdateGame();
AvpShowViews();
MaintainHUD();
CheckCDAndChooseTrackIfNeeded();
if(InGameMenusAreRunning() && ( (AvP.Network!=I_No_Network && netGameData.skirmishMode) || (AvP.Network==I_No_Network)) ) {
SoundSys_StopAll();
}
} else {
ReadUserInput();
SoundSys_Management();
FlushD3DZBuffer();
ThisFramesRenderingHasBegun();
}
menusActive = AvP_InGameMenus();
if (AvP.RestartLevel) menusActive=0;
if (AvP.LevelCompleted) {
SoundSys_FadeOutFast();
DoCompletedLevelStatisticsScreen();
thisLevelHasBeenCompleted = 1;
}
ThisFramesRenderingHasFinished();
InGameFlipBuffers();
FrameCounterHandler();
{
PLAYER_STATUS *playerStatusPtr = (PLAYER_STATUS *) (Player->ObStrategyBlock->SBdataptr);
if (!menusActive && playerStatusPtr->IsAlive && !AvP.LevelCompleted) {
DealWithElapsedTime();
}
}
break;
case I_GM_Menus:
AvP.GameMode = I_GM_Playing;
break;
default:
fprintf(stderr, "AvP.MainLoopRunning: gamemode = %d\n", AvP.GameMode);
exit(EXIT_FAILURE);
}
if (AvP.RestartLevel) {
AvP.RestartLevel = 0;
AvP.LevelCompleted = 0;
FixCheatModesInUserProfile(UserProfilePtr);
RestartLevel();
}
}
return AvP.MainLoopRunning;
}
static int MainGame_Deinit(void) {
AvP.LevelCompleted = thisLevelHasBeenCompleted;
FixCheatModesInUserProfile(UserProfilePtr);
ReleaseAllFMVTextures();
CONSBIND_WriteKeyBindingsToConfigFile();
DeInitialisePlayer();
DeallocatePlayersMirrorImage();
KillHUD();
Destroy_CurrentEnvironment();
DeallocateAllImages();
EndNPCs();
ExitGame();
SoundSys_StopAll();
SoundSys_ResetFadeLevel();
CDDA_Stop();
if (AvP.Network != I_No_Network) {
EndAVPNetGame();
}
ClearMemoryPool();
/* go back to menu mode */
#if !(ALIEN_DEMO|PREDATOR_DEMO|MARINE_DEMO)
SetSoftVideoMode(640, 480, 16);
#endif
return 0; return 0;
} }

2
src/mathline.h
View file

@ -31,7 +31,7 @@
them though. them though.
*/ */
static inline int MUL_FIXED(int a, int b) static __inline int MUL_FIXED(int a, int b)
{ {
/* /*
int retval; int retval;

32
src/menus.c
View file

@ -374,7 +374,7 @@ int LengthOfMenuText(const char *textPtr)
int width = 0; int width = 0;
while (textPtr && *textPtr) { while (textPtr && *textPtr) {
width += IntroFont_Light.FontWidth[(unsigned int) *textPtr]; width += IntroFont_Light.FontWidth[(unsigned char) *textPtr];
textPtr++; textPtr++;
} }
@ -386,7 +386,7 @@ int LengthOfSmallMenuText(char *textPtr)
int width = 0; int width = 0;
while (textPtr && *textPtr) { while (textPtr && *textPtr) {
width += AAFontWidths[(unsigned int) *textPtr]; width += AAFontWidths[(unsigned char) *textPtr];
textPtr++; textPtr++;
} }
@ -445,7 +445,7 @@ int RenderMenuText(const char *textPtr, int sx, int sy, int alpha, enum AVPMENUF
unsigned int topLeftU = 0; unsigned int topLeftU = 0;
unsigned int topLeftV = 1+(c-32)*33; unsigned int topLeftV = 1+(c-32)*33;
unsigned int x, y; unsigned int x, y;
unsigned int width = IntroFont_Light.FontWidth[(unsigned int) c]; unsigned int width = IntroFont_Light.FontWidth[(unsigned char) c];
unsigned int remainder = 0; unsigned int remainder = 0;
unsigned int stride = width; unsigned int stride = width;
@ -550,7 +550,7 @@ int RenderMenuText_Clipped(char *textPtr, int sx, int sy, int alpha, enum AVPMEN
unsigned int topLeftU = 0; unsigned int topLeftU = 0;
unsigned int topLeftV = 1+(c-32)*33; unsigned int topLeftV = 1+(c-32)*33;
unsigned int x, y; unsigned int x, y;
unsigned int width = IntroFont_Light.FontWidth[(unsigned int) c]; unsigned int width = IntroFont_Light.FontWidth[(unsigned char) c];
unsigned int remainder = 0; unsigned int remainder = 0;
unsigned int stride = width; unsigned int stride = width;
@ -665,7 +665,7 @@ static int RenderSmallFontString(char *textPtr,int sx,int sy,int alpha, int red,
} }
srcPtr += (image->w - HUD_FONT_WIDTH) * 4; srcPtr += (image->w - HUD_FONT_WIDTH) * 4;
} }
sx += AAFontWidths[(unsigned int) c]; sx += AAFontWidths[(unsigned char) c];
} }
} }
@ -699,11 +699,11 @@ Determine area used by text , so we can draw it centrally
int widthFromChars=0; int widthFromChars=0;
while(*textPtr2 && *textPtr2==' ') { while(*textPtr2 && *textPtr2==' ') {
widthFromSpaces+=AAFontWidths[(unsigned int) *textPtr2++]; widthFromSpaces+=AAFontWidths[(unsigned char) *textPtr2++];
} }
while(*textPtr2 && *textPtr2!=' ') { while(*textPtr2 && *textPtr2!=' ') {
widthFromChars+=AAFontWidths[(unsigned int) *textPtr2++]; widthFromChars+=AAFontWidths[(unsigned char) *textPtr2++];
} }
wordWidth=widthFromSpaces+widthFromChars; wordWidth=widthFromSpaces+widthFromChars;
@ -762,11 +762,11 @@ Determine area used by text , so we can draw it centrally
wordWidth=0; wordWidth=0;
while(*textPtr2 && *textPtr2==' ') { while(*textPtr2 && *textPtr2==' ') {
wordWidth+=AAFontWidths[(unsigned int) *textPtr2++]; wordWidth+=AAFontWidths[(unsigned char) *textPtr2++];
} }
while(*textPtr2 && *textPtr2!=' ') { while(*textPtr2 && *textPtr2!=' ') {
wordWidth+=AAFontWidths[(unsigned int) *textPtr2++]; wordWidth+=AAFontWidths[(unsigned char) *textPtr2++];
} }
if(wordWidth> area->right-sx) { if(wordWidth> area->right-sx) {
@ -790,7 +790,7 @@ Determine area used by text , so we can draw it centrally
} }
while(*textPtr && *textPtr==' ') { while(*textPtr && *textPtr==' ') {
sx+=AAFontWidths[(unsigned int) *textPtr++]; sx+=AAFontWidths[(unsigned char) *textPtr++];
} }
if(sx>area->right) { if(sx>area->right) {
@ -804,7 +804,7 @@ Determine area used by text , so we can draw it centrally
while(*textPtr && *textPtr!=' ') { while(*textPtr && *textPtr!=' ') {
char c = *textPtr++; char c = *textPtr++;
int letterWidth = AAFontWidths[(unsigned int) c]; int letterWidth = AAFontWidths[(unsigned char) c];
if(sx+letterWidth>area->right) { if(sx+letterWidth>area->right) {
sx=area->left; sx=area->left;
@ -847,7 +847,7 @@ Determine area used by text , so we can draw it centrally
} }
srcPtr += (image->w - HUD_FONT_WIDTH) * 4; srcPtr += (image->w - HUD_FONT_WIDTH) * 4;
} }
sx += AAFontWidths[(unsigned int) c]; sx += AAFontWidths[(unsigned char) c];
} }
} }
} }
@ -876,7 +876,7 @@ int RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AVPMENUFORM
ptr = textPtr; ptr = textPtr;
while (*ptr) { while (*ptr) {
length+=AAFontWidths[(unsigned int) *ptr++]; length+=AAFontWidths[(unsigned char) *ptr++];
} }
x -= length; x -= length;
@ -886,7 +886,7 @@ int RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AVPMENUFORM
ptr = textPtr; ptr = textPtr;
while (*ptr) { while (*ptr) {
length+=AAFontWidths[(unsigned int) *ptr++]; length+=AAFontWidths[(unsigned char) *ptr++];
} }
x -= length / 2; x -= length / 2;
@ -914,7 +914,7 @@ int RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha, enum AV
ptr = textPtr; ptr = textPtr;
while (*ptr) { while (*ptr) {
length+=AAFontWidths[(unsigned int) *ptr++]; length+=AAFontWidths[(unsigned char) *ptr++];
} }
x -= length; x -= length;
@ -924,7 +924,7 @@ int RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha, enum AV
ptr = textPtr; ptr = textPtr;
while (*ptr) { while (*ptr) {
length+=AAFontWidths[(unsigned int) *ptr++]; length+=AAFontWidths[(unsigned char) *ptr++];
} }
x -= length / 2; x -= length / 2;

289
src/oglfunc.c
View file

@ -1,3 +1,4 @@
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -5,51 +6,86 @@
#include "oglfunc.h" #include "oglfunc.h"
PFNGLALPHAFUNCPROC pglAlphaFunc; // Base OpenGL / OpenGL ES
PFNGLBINDTEXTUREPROC pglBindTexture; avpPFNGLACTIVETEXTUREPROC pglActiveTexture;
PFNGLBLENDFUNCPROC pglBlendFunc; avpPFNGLBINDTEXTUREPROC pglBindTexture;
PFNGLCLEARPROC pglClear; avpPFNGLBLENDFUNCPROC pglBlendFunc;
PFNGLCLEARCOLORPROC pglClearColor; avpPFNGLCLEARPROC pglClear;
PFNGLCOLOR4FPROC pglColor4f; avpPFNGLCLEARCOLORPROC pglClearColor;
PFNGLCOLORPOINTERPROC pglColorPointer; avpPFNGLCULLFACEPROC pglCullFace;
PFNGLCULLFACEPROC pglCullFace; avpPFNGLDELETETEXTURESPROC pglDeleteTextures;
PFNGLDELETETEXTURESPROC pglDeleteTextures; avpPFNGLDEPTHFUNCPROC pglDepthFunc;
PFNGLDEPTHFUNCPROC pglDepthFunc; avpPFNGLDEPTHMASKPROC pglDepthMask;
PFNGLDEPTHMASKPROC pglDepthMask; avpPFNGLDEPTHRANGEPROC pglDepthRange;
PFNGLDEPTHRANGEPROC pglDepthRange; avpPFNGLDISABLEPROC pglDisable;
PFNGLDISABLEPROC pglDisable; avpPFNGLDRAWELEMENTSPROC pglDrawElements;
PFNGLDISABLECLIENTSTATEPROC pglDisableClientState; avpPFNGLENABLEPROC pglEnable;
PFNGLDRAWELEMENTSPROC pglDrawElements; avpPFNGLFRONTFACEPROC pglFrontFace;
PFNGLENABLEPROC pglEnable; avpPFNGLGENTEXTURESPROC pglGenTextures;
PFNGLENABLECLIENTSTATEPROC pglEnableClientState; avpPFNGLGETERRORPROC pglGetError;
PFNGLFRONTFACEPROC pglFrontFace; avpPFNGLGETFLOATVPROC pglGetFloatv;
PFNGLGENTEXTURESPROC pglGenTextures; avpPFNGLGETINTEGERVPROC pglGetIntegerv;
PFNGLGETERRORPROC pglGetError; avpPFNGLGETSTRINGPROC pglGetString;
PFNGLGETFLOATVPROC pglGetFloatv; avpPFNGLGETTEXPARAMETERFVPROC pglGetTexParameterfv;
PFNGLGETINTEGERVPROC pglGetIntegerv; avpPFNGLHINTPROC pglHint;
PFNGLGETSTRINGPROC pglGetString; avpPFNGLPIXELSTOREIPROC pglPixelStorei;
PFNGLGETTEXPARAMETERFVPROC pglGetTexParameterfv; avpPFNGLPOLYGONOFFSETPROC pglPolygonOffset;
PFNGLHINTPROC pglHint; avpPFNGLREADPIXELSPROC pglReadPixels;
PFNGLPIXELSTOREIPROC pglPixelStorei; avpPFNGLTEXIMAGE2DPROC pglTexImage2D;
PFNGLPOLYGONOFFSETPROC pglPolygonOffset; avpPFNGLTEXPARAMETERFPROC pglTexParameterf;
PFNGLREADPIXELSPROC pglReadPixels; avpPFNGLTEXPARAMETERIPROC pglTexParameteri;
PFNGLSHADEMODELPROC pglShadeModel; avpPFNGLTEXSUBIMAGE2DPROC pglTexSubImage2D;
PFNGLTEXCOORDPOINTERPROC pglTexCoordPointer; avpPFNGLVIEWPORTPROC pglViewport;
PFNGLTEXENVFPROC pglTexEnvf;
PFNGLTEXENVFVPROC pglTexEnvfv; // OpenGL 2.1 / OpenGL ES 2.0
PFNGLTEXENVIPROC pglTexEnvi; avpPFNGLATTACHSHADERPROC pglAttachShader;
PFNGLTEXIMAGE2DPROC pglTexImage2D; avpPFNGLBINDATTRIBLOCATIONPROC pglBindAttribLocation;
PFNGLTEXPARAMETERFPROC pglTexParameterf; avpPFNGLBINDBUFFERPROC pglBindBuffer;
PFNGLTEXPARAMETERIPROC pglTexParameteri; avpPFNGLBUFFERDATAPROC pglBufferData;
PFNGLTEXSUBIMAGE2DPROC pglTexSubImage2D; avpPFNGLBUFFERSUBDATAPROC pglBufferSubData;
PFNGLVERTEXPOINTERPROC pglVertexPointer; avpPFNGLCREATEPROGRAMPROC pglCreateProgram;
PFNGLVIEWPORTPROC pglViewport; avpPFNGLCREATESHADERPROC pglCreateShader;
avpPFNGLCOMPILESHADERPROC pglCompileShader;
avpPFNGLDELETEBUFFERSPROC pglDeleteBuffers;
avpPFNGLDELETEPROGRAMPROC pglDeleteProgram;
avpPFNGLDELETESHADERPROC pglDeleteShader;
avpPFNGLDISABLEVERTEXATTRIBARRAYPROC pglDisableVertexAttribArray;
avpPFNGLENABLEVERTEXATTRIBARRAYPROC pglEnableVertexAttribArray;
avpPFNGLGENBUFFERSPROC pglGenBuffers;
avpPFNGLGETATTRIBLOCATIONPROC pglGetAttribLocation;
avpPFNGLGETPROGRAMINFOLOGPROC pglGetProgramInfoLog;
avpPFNGLGETPROGRAMIVPROC pglGetProgramiv;
avpPFNGLGETSHADERINFOLOGPROC pglGetShaderInfoLog;
avpPFNGLGETSHADERIVPROC pglGetShaderiv;
avpPFNGLGETUNIFORMLOCATIONPROC pglGetUniformLocation;
avpPFNGLLINKPROGRAMPROC pglLinkProgram;
avpPFNGLSHADERSOURCEPROC pglShaderSource;
avpPFNGLVALIDATEPROGRAMPROC pglValidateProgram;
avpPFNGLVERTEXATTRIBPOINTERPROC pglVertexAttribPointer;
avpPFNGLUNIFORM1IPROC pglUniform1i;
avpPFNGLUNIFORMMATRIX4FVPROC pglUniformMatrix4fv;
avpPFNGLUSEPROGRAMPROC pglUseProgram;
// GL_EXT_framebuffer_object / GL_ARB_framebuffer_object / OpenGL ES 2.0
avpPFNGLBINDFRAMEBUFFERPROC pglBindFramebuffer;
avpPFNGLBINDRENDERBUFFERPROC pglBindRenderbuffer;
avpPFNGLCHECKFRAMEBUFFERSTATUSPROC pglCheckFramebufferStatus;
avpPFNGLDELETEFRAMEBUFFERSPROC pglDeleteFramebuffers;
avpPFNGLDELETERENDERBUFFERSPROC pglDeleteRenderbuffers;
avpPFNGLFRAMEBUFFERRENDERBUFFERPROC pglFramebufferRenderbuffer;
avpPFNGLFRAMEBUFFERTEXTURE2DPROC pglFramebufferTexture2D;
avpPFNGLGENERATEMIPMAPPROC pglGenerateMipmap;
avpPFNGLGENFRAMEBUFFERSPROC pglGenFramebuffers;
avpPFNGLGENRENDERBUFFERSPROC pglGenRenderbuffers;
avpPFNGLRENDERBUFFERSTORAGEPROC pglRenderbufferStorage;
int ogl_have_multisample_filter_hint; int ogl_have_multisample_filter_hint;
int ogl_have_texture_filter_anisotropic; int ogl_have_texture_filter_anisotropic;
int ogl_have_framebuffer_object;
int ogl_use_multisample_filter_hint; int ogl_use_multisample_filter_hint;
int ogl_use_texture_filter_anisotropic; int ogl_use_texture_filter_anisotropic;
int ogl_use_framebuffer_object;
static void dummyfunc() static void dummyfunc()
{ {
@ -73,6 +109,20 @@ static void dummyfunc()
LoadOGLProc_(type, func1, func2); \ LoadOGLProc_(type, func1, func2); \
} }
#define LoadOGLExtProc(e, type, func) \
if ((e)) { \
LoadOGLProc(type, func); \
} else { \
p##func = NULL; \
}
#define LoadOGLExtProc2(e, type, func1, func2) \
if ((e)) { \
LoadOGLProc2(type, func1, func2); \
} else { \
p##func = NULL; \
}
static int check_token(const char *string, const char *token) static int check_token(const char *string, const char *token)
{ {
const char *s = string; const char *s = string;
@ -98,47 +148,71 @@ void load_ogl_functions(int mode)
const char* ogl_missing_func; const char* ogl_missing_func;
const char* ext; const char* ext;
int base_framebuffer_object;
int ext_framebuffer_object;
int arb_framebuffer_object;
ogl_missing_func = NULL; ogl_missing_func = NULL;
LoadOGLProc(PFNGLALPHAFUNCPROC, glAlphaFunc); // Base OpenGL / OpenGL ES
LoadOGLProc(PFNGLBINDTEXTUREPROC, glBindTexture); LoadOGLProc(avpPFNGLACTIVETEXTUREPROC, glActiveTexture);
LoadOGLProc(PFNGLBLENDFUNCPROC, glBlendFunc); LoadOGLProc(avpPFNGLBINDTEXTUREPROC, glBindTexture);
LoadOGLProc(PFNGLCLEARPROC, glClear); LoadOGLProc(avpPFNGLBLENDFUNCPROC, glBlendFunc);
LoadOGLProc(PFNGLCLEARCOLORPROC, glClearColor); LoadOGLProc(avpPFNGLCLEARPROC, glClear);
LoadOGLProc(PFNGLCOLOR4FPROC, glColor4f); LoadOGLProc(avpPFNGLCLEARCOLORPROC, glClearColor);
LoadOGLProc(PFNGLCOLORPOINTERPROC, glColorPointer); LoadOGLProc(avpPFNGLCULLFACEPROC, glCullFace);
LoadOGLProc(PFNGLCULLFACEPROC, glCullFace); LoadOGLProc(avpPFNGLDELETETEXTURESPROC, glDeleteTextures);
LoadOGLProc(PFNGLDELETETEXTURESPROC, glDeleteTextures); LoadOGLProc(avpPFNGLDEPTHFUNCPROC, glDepthFunc);
LoadOGLProc(PFNGLDEPTHFUNCPROC, glDepthFunc); LoadOGLProc(avpPFNGLDEPTHMASKPROC, glDepthMask);
LoadOGLProc(PFNGLDEPTHMASKPROC, glDepthMask); LoadOGLProc2(avpPFNGLDEPTHRANGEPROC, glDepthRange, glDepthRangef);
LoadOGLProc2(PFNGLDEPTHRANGEPROC, glDepthRange, glDepthRangef); LoadOGLProc(avpPFNGLDISABLEPROC, glDisable);
LoadOGLProc(PFNGLDISABLEPROC, glDisable); LoadOGLProc(avpPFNGLDRAWELEMENTSPROC, glDrawElements);
LoadOGLProc(PFNGLDISABLECLIENTSTATEPROC, glDisableClientState); LoadOGLProc(avpPFNGLENABLEPROC, glEnable);
LoadOGLProc(PFNGLDRAWELEMENTSPROC, glDrawElements); LoadOGLProc(avpPFNGLFRONTFACEPROC, glFrontFace);
LoadOGLProc(PFNGLENABLEPROC, glEnable); LoadOGLProc(avpPFNGLGENTEXTURESPROC, glGenTextures);
LoadOGLProc(PFNGLENABLECLIENTSTATEPROC, glEnableClientState); LoadOGLProc(avpPFNGLGETERRORPROC, glGetError);
LoadOGLProc(PFNGLFRONTFACEPROC, glFrontFace); LoadOGLProc(avpPFNGLGETFLOATVPROC, glGetFloatv);
LoadOGLProc(PFNGLGENTEXTURESPROC, glGenTextures); LoadOGLProc(avpPFNGLGETINTEGERVPROC, glGetIntegerv);
LoadOGLProc(PFNGLGETERRORPROC, glGetError); LoadOGLProc(avpPFNGLGETSTRINGPROC, glGetString);
LoadOGLProc(PFNGLGETFLOATVPROC, glGetFloatv); LoadOGLProc(avpPFNGLGETTEXPARAMETERFVPROC, glGetTexParameterfv);
LoadOGLProc(PFNGLGETINTEGERVPROC, glGetIntegerv); LoadOGLProc(avpPFNGLHINTPROC, glHint);
LoadOGLProc(PFNGLGETSTRINGPROC, glGetString); LoadOGLProc(avpPFNGLPIXELSTOREIPROC, glPixelStorei);
LoadOGLProc(PFNGLGETTEXPARAMETERFVPROC, glGetTexParameterfv); LoadOGLProc(avpPFNGLPOLYGONOFFSETPROC, glPolygonOffset);
LoadOGLProc(PFNGLHINTPROC, glHint); LoadOGLProc(avpPFNGLREADPIXELSPROC, glReadPixels);
LoadOGLProc(PFNGLPIXELSTOREIPROC, glPixelStorei); LoadOGLProc(avpPFNGLTEXIMAGE2DPROC, glTexImage2D);
LoadOGLProc(PFNGLPOLYGONOFFSETPROC, glPolygonOffset); LoadOGLProc(avpPFNGLTEXPARAMETERFPROC, glTexParameterf);
LoadOGLProc(PFNGLREADPIXELSPROC, glReadPixels); LoadOGLProc(avpPFNGLTEXPARAMETERIPROC, glTexParameteri);
LoadOGLProc(PFNGLSHADEMODELPROC, glShadeModel); LoadOGLProc(avpPFNGLTEXSUBIMAGE2DPROC, glTexSubImage2D);
LoadOGLProc(PFNGLTEXCOORDPOINTERPROC, glTexCoordPointer); LoadOGLProc(avpPFNGLVIEWPORTPROC, glViewport);
LoadOGLProc(PFNGLTEXENVFPROC, glTexEnvf);
LoadOGLProc(PFNGLTEXENVFVPROC, glTexEnvfv); // OpenGL 2.1 / OpenGL ES 2.0
LoadOGLProc(PFNGLTEXENVIPROC, glTexEnvi); LoadOGLProc(avpPFNGLATTACHSHADERPROC, glAttachShader);
LoadOGLProc(PFNGLTEXIMAGE2DPROC, glTexImage2D); LoadOGLProc(avpPFNGLBINDATTRIBLOCATIONPROC, glBindAttribLocation);
LoadOGLProc(PFNGLTEXPARAMETERFPROC, glTexParameterf); LoadOGLProc(avpPFNGLBINDBUFFERPROC, glBindBuffer);
LoadOGLProc(PFNGLTEXPARAMETERIPROC, glTexParameteri); LoadOGLProc(avpPFNGLBUFFERDATAPROC, glBufferData);
LoadOGLProc(PFNGLTEXSUBIMAGE2DPROC, glTexSubImage2D); LoadOGLProc(avpPFNGLBUFFERSUBDATAPROC, glBufferSubData);
LoadOGLProc(PFNGLVERTEXPOINTERPROC, glVertexPointer); LoadOGLProc(avpPFNGLCREATEPROGRAMPROC, glCreateProgram);
LoadOGLProc(PFNGLVIEWPORTPROC, glViewport); LoadOGLProc(avpPFNGLCREATESHADERPROC, glCreateShader);
LoadOGLProc(avpPFNGLCOMPILESHADERPROC, glCompileShader);
LoadOGLProc(avpPFNGLDELETEBUFFERSPROC, glDeleteBuffers);
LoadOGLProc(avpPFNGLDELETEPROGRAMPROC, glDeleteProgram);
LoadOGLProc(avpPFNGLDELETESHADERPROC, glDeleteShader);
LoadOGLProc(avpPFNGLDISABLEVERTEXATTRIBARRAYPROC, glDisableVertexAttribArray);
LoadOGLProc(avpPFNGLENABLEVERTEXATTRIBARRAYPROC, glEnableVertexAttribArray);
LoadOGLProc(avpPFNGLGENBUFFERSPROC, glGenBuffers);
LoadOGLProc(avpPFNGLGETATTRIBLOCATIONPROC, glGetAttribLocation);
LoadOGLProc(avpPFNGLGETPROGRAMINFOLOGPROC, glGetProgramInfoLog);
LoadOGLProc(avpPFNGLGETPROGRAMIVPROC, glGetProgramiv);
LoadOGLProc(avpPFNGLGETSHADERINFOLOGPROC, glGetShaderInfoLog);
LoadOGLProc(avpPFNGLGETSHADERIVPROC, glGetShaderiv);
LoadOGLProc(avpPFNGLGETUNIFORMLOCATIONPROC, glGetUniformLocation);
LoadOGLProc(avpPFNGLLINKPROGRAMPROC, glLinkProgram);
LoadOGLProc(avpPFNGLSHADERSOURCEPROC, glShaderSource);
LoadOGLProc(avpPFNGLVALIDATEPROGRAMPROC, glValidateProgram);
LoadOGLProc(avpPFNGLVERTEXATTRIBPOINTERPROC, glVertexAttribPointer);
LoadOGLProc(avpPFNGLUNIFORM1IPROC, glUniform1i);
LoadOGLProc(avpPFNGLUNIFORMMATRIX4FVPROC, glUniformMatrix4fv);
LoadOGLProc(avpPFNGLUSEPROGRAMPROC, glUseProgram);
if (!mode) { if (!mode) {
return; return;
@ -153,17 +227,74 @@ void load_ogl_functions(int mode)
printf("GL_VENDOR: %s\n", pglGetString(GL_VENDOR)); printf("GL_VENDOR: %s\n", pglGetString(GL_VENDOR));
printf("GL_RENDERER: %s\n", pglGetString(GL_RENDERER)); printf("GL_RENDERER: %s\n", pglGetString(GL_RENDERER));
printf("GL_VERSION: %s\n", pglGetString(GL_VERSION)); printf("GL_VERSION: %s\n", pglGetString(GL_VERSION));
//printf("GL_SHADING_LANGUAGE_VERSION: %s\n", pglGetString(GL_SHADING_LANGUAGE_VERSION)); printf("GL_SHADING_LANGUAGE_VERSION: %s\n", pglGetString(GL_SHADING_LANGUAGE_VERSION));
printf("GL_EXTENSIONS: %s\n", pglGetString(GL_EXTENSIONS)); printf("GL_EXTENSIONS: %s\n", pglGetString(GL_EXTENSIONS));
#endif #endif
ext = (const char *) pglGetString(GL_EXTENSIONS); ext = (const char *) pglGetString(GL_EXTENSIONS);
// GL_EXT_framebuffer_object / GL_ARB_framebuffer_object / OpenGL ES 2.0
// figure out which version of framebuffer objects to use, if any
ext_framebuffer_object = check_token(ext, "GL_EXT_framebuffer_object");
arb_framebuffer_object = check_token(ext, "GL_ARB_framebuffer_object");
#if defined(USE_OPENGL_ES)
// not quite right as ARB fbo includes functionality not present in ES2.
base_framebuffer_object = 1;
#else
base_framebuffer_object = arb_framebuffer_object;
#endif
ogl_missing_func = NULL;
LoadOGLExtProc(base_framebuffer_object, avpPFNGLBINDFRAMEBUFFERPROC, glBindFramebuffer);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLBINDRENDERBUFFERPROC, glBindRenderbuffer);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLCHECKFRAMEBUFFERSTATUSPROC, glCheckFramebufferStatus);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLDELETEFRAMEBUFFERSPROC, glDeleteFramebuffers);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLDELETERENDERBUFFERSPROC, glDeleteRenderbuffers);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLFRAMEBUFFERRENDERBUFFERPROC, glFramebufferRenderbuffer);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLFRAMEBUFFERTEXTURE2DPROC, glFramebufferTexture2D);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLGENERATEMIPMAPPROC, glGenerateMipmap);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLGENFRAMEBUFFERSPROC, glGenFramebuffers);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLGENRENDERBUFFERSPROC, glGenRenderbuffers);
LoadOGLExtProc(base_framebuffer_object, avpPFNGLRENDERBUFFERSTORAGEPROC, glRenderbufferStorage);
if (base_framebuffer_object != 0 && ogl_missing_func == NULL) {
ogl_have_framebuffer_object = 1;
#if !defined(NDEBUG)
printf("ARB/ES2 framebuffer objects enabled.\n");
#endif
}
if (ext_framebuffer_object != 0 && ogl_have_framebuffer_object == 0) {
// try the EXT suffixed functions
ogl_missing_func = NULL;
LoadOGLProc_(avpPFNGLBINDFRAMEBUFFERPROC, glBindFramebuffer, glBindFramebufferEXT);
LoadOGLProc_(avpPFNGLBINDRENDERBUFFERPROC, glBindRenderbuffer, glBindRenderbufferEXT);
LoadOGLProc_(avpPFNGLCHECKFRAMEBUFFERSTATUSPROC, glCheckFramebufferStatus, glCheckFramebufferStatusEXT);
LoadOGLProc_(avpPFNGLDELETEFRAMEBUFFERSPROC, glDeleteFramebuffers, glDeleteFramebuffersEXT);
LoadOGLProc_(avpPFNGLDELETERENDERBUFFERSPROC, glDeleteRenderbuffers, glDeleteRenderbuffersEXT);
LoadOGLProc_(avpPFNGLFRAMEBUFFERRENDERBUFFERPROC, glFramebufferRenderbuffer, glFramebufferRenderbufferEXT);
LoadOGLProc_(avpPFNGLFRAMEBUFFERTEXTURE2DPROC, glFramebufferTexture2D, glFramebufferTexture2DEXT);
LoadOGLProc_(avpPFNGLGENERATEMIPMAPPROC, glGenerateMipmap, glGenerateMipmapEXT);
LoadOGLProc_(avpPFNGLGENFRAMEBUFFERSPROC, glGenFramebuffers, glGenFramebuffersEXT);
LoadOGLProc_(avpPFNGLGENRENDERBUFFERSPROC, glGenRenderbuffers, glGenRenderbuffersEXT);
LoadOGLProc_(avpPFNGLRENDERBUFFERSTORAGEPROC, glRenderbufferStorage, glRenderbufferStorageEXT);
if (ogl_missing_func == NULL) {
ogl_have_framebuffer_object = 1;
#if !defined(NDEBUG)
printf("EXT framebuffer objects enabled.\n");
#endif
}
}
// other extensions
ogl_have_multisample_filter_hint = check_token(ext, "GL_NV_multisample_filter_hint"); ogl_have_multisample_filter_hint = check_token(ext, "GL_NV_multisample_filter_hint");
ogl_have_texture_filter_anisotropic = check_token(ext, "GL_EXT_texture_filter_anisotropic"); ogl_have_texture_filter_anisotropic = check_token(ext, "GL_EXT_texture_filter_anisotropic");
ogl_use_multisample_filter_hint = ogl_have_multisample_filter_hint; ogl_use_multisample_filter_hint = ogl_have_multisample_filter_hint;
ogl_use_texture_filter_anisotropic = ogl_have_texture_filter_anisotropic; ogl_use_texture_filter_anisotropic = ogl_have_texture_filter_anisotropic;
ogl_use_framebuffer_object = ogl_have_framebuffer_object;
} }
int check_for_errors_(const char *file, int line) int check_for_errors_(const char *file, int line)

226
src/oglfunc.h
View file

@ -5,8 +5,10 @@
#include <windows.h> #include <windows.h>
#endif #endif
#include "SDL_version.h"
#if defined(USE_OPENGL_ES) #if defined(USE_OPENGL_ES)
#include "SDL_opengles.h" #include "SDL_opengles2.h"
// OpenGL compatibility // OpenGL compatibility
typedef GLclampf GLclampd; typedef GLclampf GLclampd;
@ -25,91 +27,157 @@ typedef GLfloat GLdouble;
#define APIENTRY #define APIENTRY
#endif #endif
typedef void (APIENTRY *PFNGLALPHAFUNCPROC)(GLenum, GLclampf); // Base OpenGL / OpenGL ES
typedef void (APIENTRY *PFNGLBINDTEXTUREPROC)(GLenum, GLuint); typedef void (APIENTRY *avpPFNGLACTIVETEXTUREPROC)(GLenum);
typedef void (APIENTRY *PFNGLBLENDFUNCPROC)(GLenum, GLenum); typedef void (APIENTRY *avpPFNGLBINDTEXTUREPROC)(GLenum, GLuint);
typedef void (APIENTRY *PFNGLCLEARPROC)(GLbitfield); typedef void (APIENTRY *avpPFNGLBLENDFUNCPROC)(GLenum, GLenum);
typedef void (APIENTRY *PFNGLCLEARCOLORPROC)(GLclampf, GLclampf, GLclampf, GLclampf); typedef void (APIENTRY *avpPFNGLCLEARPROC)(GLbitfield);
typedef void (APIENTRY *PFNGLCOLOR4FPROC)(GLfloat, GLfloat, GLfloat, GLfloat); typedef void (APIENTRY *avpPFNGLCLEARCOLORPROC)(GLclampf, GLclampf, GLclampf, GLclampf);
typedef void (APIENTRY *PFNGLCOLORPOINTERPROC)(GLint, GLenum, GLsizei, const GLvoid *); typedef void (APIENTRY *avpPFNGLCULLFACEPROC)(GLenum);
typedef void (APIENTRY *PFNGLCULLFACEPROC)(GLenum); typedef void (APIENTRY *avpPFNGLDELETETEXTURESPROC)(GLsizei,const GLuint*);
typedef void (APIENTRY *PFNGLDELETETEXTURESPROC)(GLsizei,const GLuint*); typedef void (APIENTRY *avpPFNGLDEPTHFUNCPROC)(GLenum);
typedef void (APIENTRY *PFNGLDEPTHFUNCPROC)(GLenum); typedef void (APIENTRY *avpPFNGLDEPTHMASKPROC)(GLboolean);
typedef void (APIENTRY *PFNGLDEPTHMASKPROC)(GLboolean); typedef void (APIENTRY *avpPFNGLDEPTHRANGEPROC)(GLclampd, GLclampd);
typedef void (APIENTRY *PFNGLDEPTHRANGEPROC)(GLclampd, GLclampd); typedef void (APIENTRY *avpPFNGLDISABLEPROC)(GLenum);
typedef void (APIENTRY *PFNGLDISABLEPROC)(GLenum); typedef void (APIENTRY *avpPFNGLDRAWELEMENTSPROC)(GLenum, GLsizei, GLenum, const GLvoid *);
typedef void (APIENTRY *PFNGLDISABLECLIENTSTATEPROC)(GLenum); typedef void (APIENTRY *avpPFNGLENABLEPROC)(GLenum);
typedef void (APIENTRY *PFNGLDRAWELEMENTSPROC)(GLenum, GLsizei, GLenum, const GLvoid *); typedef void (APIENTRY *avpPFNGLFRONTFACEPROC)(GLenum);
typedef void (APIENTRY *PFNGLENABLEPROC)(GLenum); typedef void (APIENTRY *avpPFNGLGENTEXTURESPROC)(GLsizei,GLuint*);
typedef void (APIENTRY *PFNGLENABLECLIENTSTATEPROC)(GLenum); typedef GLenum (APIENTRY *avpPFNGLGETERRORPROC)(void);
typedef void (APIENTRY *PFNGLFRONTFACEPROC)(GLenum); typedef void (APIENTRY *avpPFNGLGETFLOATVPROC)(GLenum, GLfloat *);
typedef void (APIENTRY *PFNGLGENTEXTURESPROC)(GLsizei,GLuint*); typedef void (APIENTRY *avpPFNGLGETINTEGERVPROC)(GLenum, GLint *);
typedef GLenum (APIENTRY *PFNGLGETERRORPROC)(void); typedef const GLubyte* (APIENTRY *avpPFNGLGETSTRINGPROC)(GLenum);
typedef void (APIENTRY *PFNGLGETFLOATVPROC)(GLenum, GLfloat *); typedef void (APIENTRY *avpPFNGLGETTEXPARAMETERFVPROC)(GLenum, GLenum, GLfloat*);
typedef void (APIENTRY *PFNGLGETINTEGERVPROC)(GLenum, GLint *); typedef void (APIENTRY *avpPFNGLHINTPROC)(GLenum, GLenum);
typedef const GLubyte* (APIENTRY *PFNGLGETSTRINGPROC)(GLenum); typedef void (APIENTRY *avpPFNGLPIXELSTOREIPROC)(GLenum, GLint);
typedef void (APIENTRY *PFNGLGETTEXPARAMETERFVPROC)(GLenum, GLenum, GLfloat*); typedef void (APIENTRY *avpPFNGLPOLYGONOFFSETPROC)(GLfloat, GLfloat);
typedef void (APIENTRY *PFNGLHINTPROC)(GLenum, GLenum); typedef void (APIENTRY *avpPFNGLREADPIXELSPROC)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *);
typedef void (APIENTRY *PFNGLPIXELSTOREIPROC)(GLenum, GLint); typedef void (APIENTRY *avpPFNGLTEXIMAGE2DPROC)(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const GLvoid*);
typedef void (APIENTRY *PFNGLPOLYGONOFFSETPROC)(GLfloat, GLfloat); typedef void (APIENTRY *avpPFNGLTEXPARAMETERFPROC)(GLenum, GLenum, GLfloat);
typedef void (APIENTRY *PFNGLREADPIXELSPROC)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *); typedef void (APIENTRY *avpPFNGLTEXPARAMETERIPROC)(GLenum, GLenum, GLint);
typedef void (APIENTRY *PFNGLSHADEMODELPROC)(GLenum); typedef void (APIENTRY *avpPFNGLTEXSUBIMAGE2DPROC)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const GLvoid*);
typedef void (APIENTRY *PFNGLTEXCOORDPOINTERPROC)(GLint, GLenum, GLsizei, const GLvoid *); typedef void (APIENTRY *avpPFNGLVIEWPORTPROC)(GLint, GLint, GLsizei, GLsizei);
typedef void (APIENTRY *PFNGLTEXENVFPROC)(GLenum, GLenum, GLfloat);
typedef void (APIENTRY *PFNGLTEXENVFVPROC)(GLenum, GLenum, const GLfloat *); extern avpPFNGLACTIVETEXTUREPROC pglActiveTexture;
typedef void (APIENTRY *PFNGLTEXENVIPROC)(GLenum, GLenum, GLint); extern avpPFNGLBINDTEXTUREPROC pglBindTexture;
typedef void (APIENTRY *PFNGLTEXIMAGE2DPROC)(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const GLvoid*); extern avpPFNGLBLENDFUNCPROC pglBlendFunc;
typedef void (APIENTRY *PFNGLTEXPARAMETERFPROC)(GLenum, GLenum, GLfloat); extern avpPFNGLCLEARPROC pglClear;
typedef void (APIENTRY *PFNGLTEXPARAMETERIPROC)(GLenum, GLenum, GLint); extern avpPFNGLCLEARCOLORPROC pglClearColor;
typedef void (APIENTRY *PFNGLTEXSUBIMAGE2DPROC)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const GLvoid*); extern avpPFNGLCULLFACEPROC pglCullFace;
typedef void (APIENTRY *PFNGLVERTEXPOINTERPROC)(GLint, GLenum, GLsizei, const GLvoid *); extern avpPFNGLDELETETEXTURESPROC pglDeleteTextures;
typedef void (APIENTRY *PFNGLVIEWPORTPROC)(GLint, GLint, GLsizei, GLsizei); extern avpPFNGLDEPTHFUNCPROC pglDepthFunc;
extern avpPFNGLDEPTHMASKPROC pglDepthMask;
extern avpPFNGLDEPTHRANGEPROC pglDepthRange;
extern avpPFNGLDISABLEPROC pglDisable;
extern avpPFNGLDRAWELEMENTSPROC pglDrawElements;
extern avpPFNGLENABLEPROC pglEnable;
extern avpPFNGLFRONTFACEPROC pglFrontFace;
extern avpPFNGLGENTEXTURESPROC pglGenTextures;
extern avpPFNGLGETERRORPROC pglGetError;
extern avpPFNGLGETFLOATVPROC pglGetFloatv;
extern avpPFNGLGETINTEGERVPROC pglGetIntegerv;
extern avpPFNGLGETSTRINGPROC pglGetString;
extern avpPFNGLGETTEXPARAMETERFVPROC pglGetTexParameterfv;
extern avpPFNGLHINTPROC pglHint;
extern avpPFNGLPIXELSTOREIPROC pglPixelStorei;
extern avpPFNGLPOLYGONOFFSETPROC pglPolygonOffset;
extern avpPFNGLREADPIXELSPROC pglReadPixels;
extern avpPFNGLTEXIMAGE2DPROC pglTexImage2D;
extern avpPFNGLTEXPARAMETERFPROC pglTexParameterf;
extern avpPFNGLTEXPARAMETERIPROC pglTexParameteri;
extern avpPFNGLTEXSUBIMAGE2DPROC pglTexSubImage2D;
extern avpPFNGLVIEWPORTPROC pglViewport;
// OpenGL 2.1 / OpenGL ES 2.0
typedef void (APIENTRY *avpPFNGLATTACHSHADERPROC)(GLuint, GLuint);
typedef void (APIENTRY *avpPFNGLBINDATTRIBLOCATIONPROC)(GLuint, GLuint, const GLchar*);
typedef void (APIENTRY *avpPFNGLBINDBUFFERPROC)(GLenum, GLuint);
typedef void (APIENTRY *avpPFNGLBUFFERDATAPROC)(GLenum, GLsizeiptr, const GLvoid*, GLenum);
typedef void (APIENTRY *avpPFNGLBUFFERSUBDATAPROC)(GLenum, GLintptr, GLsizeiptr, const GLvoid*);
typedef GLuint (APIENTRY *avpPFNGLCREATEPROGRAMPROC)(void);
typedef GLuint (APIENTRY *avpPFNGLCREATESHADERPROC)(GLenum);
typedef void (APIENTRY *avpPFNGLCOMPILESHADERPROC)(GLuint);
typedef void (APIENTRY *avpPFNGLDELETEBUFFERSPROC)(GLsizei, const GLuint*);
typedef void (APIENTRY *avpPFNGLDELETEPROGRAMPROC)(GLuint);
typedef void (APIENTRY *avpPFNGLDELETESHADERPROC)(GLuint);
typedef void (APIENTRY *avpPFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint);
typedef void (APIENTRY *avpPFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint);
typedef void (APIENTRY *avpPFNGLGENBUFFERSPROC)(GLsizei, GLuint*);
typedef int (APIENTRY *avpPFNGLGETATTRIBLOCATIONPROC)(GLuint, const GLchar*);
typedef void (APIENTRY *avpPFNGLGETPROGRAMINFOLOGPROC)(GLuint, GLsizei, GLsizei*, GLchar*);
typedef void (APIENTRY *avpPFNGLGETPROGRAMIVPROC)(GLuint, GLenum, GLint*);
typedef void (APIENTRY *avpPFNGLGETSHADERINFOLOGPROC)(GLuint, GLsizei, GLsizei*, GLchar*);
typedef void (APIENTRY *avpPFNGLGETSHADERIVPROC)(GLuint, GLenum, GLint*);
typedef int (APIENTRY *avpPFNGLGETUNIFORMLOCATIONPROC)(GLuint, const GLchar*);
typedef void (APIENTRY *avpPFNGLLINKPROGRAMPROC)(GLuint);
typedef void (APIENTRY *avpPFNGLSHADERSOURCEPROC)(GLuint, GLsizei, const GLchar* const*, const GLint*);
typedef void (APIENTRY *avpPFNGLVALIDATEPROGRAMPROC)(GLuint);
typedef void (APIENTRY *avpPFNGLVERTEXATTRIBPOINTERPROC)(GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid*);
typedef void (APIENTRY *avpPFNGLUNIFORM1IPROC)(GLint, GLint);
typedef void (APIENTRY *avpPFNGLUNIFORMMATRIX4FVPROC)(GLint, GLsizei, GLboolean, const GLfloat*);
typedef void (APIENTRY *avpPFNGLUSEPROGRAMPROC)(GLuint);
extern avpPFNGLATTACHSHADERPROC pglAttachShader;
extern avpPFNGLBINDATTRIBLOCATIONPROC pglBindAttribLocation;
extern avpPFNGLBINDBUFFERPROC pglBindBuffer;
extern avpPFNGLBUFFERDATAPROC pglBufferData;
extern avpPFNGLBUFFERSUBDATAPROC pglBufferSubData;
extern avpPFNGLCREATEPROGRAMPROC pglCreateProgram;
extern avpPFNGLCREATESHADERPROC pglCreateShader;
extern avpPFNGLCOMPILESHADERPROC pglCompileShader;
extern avpPFNGLDELETEBUFFERSPROC pglDeleteBuffers;
extern avpPFNGLDELETEPROGRAMPROC pglDeleteProgram;
extern avpPFNGLDELETESHADERPROC pglDeleteShader;
extern avpPFNGLDISABLEVERTEXATTRIBARRAYPROC pglDisableVertexAttribArray;
extern avpPFNGLENABLEVERTEXATTRIBARRAYPROC pglEnableVertexAttribArray;
extern avpPFNGLGENBUFFERSPROC pglGenBuffers;
extern avpPFNGLGETATTRIBLOCATIONPROC pglGetAttribLocation;
extern avpPFNGLGETPROGRAMINFOLOGPROC pglGetProgramInfoLog;
extern avpPFNGLGETPROGRAMIVPROC pglGetProgramiv;
extern avpPFNGLGETSHADERINFOLOGPROC pglGetShaderInfoLog;
extern avpPFNGLGETSHADERIVPROC pglGetShaderiv;
extern avpPFNGLGETUNIFORMLOCATIONPROC pglGetUniformLocation;
extern avpPFNGLLINKPROGRAMPROC pglLinkProgram;
extern avpPFNGLSHADERSOURCEPROC pglShaderSource;
extern avpPFNGLVALIDATEPROGRAMPROC pglValidateProgram;
extern avpPFNGLVERTEXATTRIBPOINTERPROC pglVertexAttribPointer;
extern avpPFNGLUNIFORM1IPROC pglUniform1i;
extern avpPFNGLUNIFORMMATRIX4FVPROC pglUniformMatrix4fv;
extern avpPFNGLUSEPROGRAMPROC pglUseProgram;
// GL_EXT_framebuffer_object / GL_ARB_framebuffer_object / OpenGL ES 2.0
typedef void (APIENTRY *avpPFNGLBINDFRAMEBUFFERPROC)(GLenum, GLuint);
typedef void (APIENTRY *avpPFNGLBINDRENDERBUFFERPROC)(GLenum, GLuint);
typedef GLenum (APIENTRY *avpPFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum);
typedef void (APIENTRY *avpPFNGLDELETEFRAMEBUFFERSPROC)(GLsizei, const GLuint*);
typedef void (APIENTRY *avpPFNGLDELETERENDERBUFFERSPROC)(GLsizei, const GLuint*);
typedef void (APIENTRY *avpPFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum, GLenum, GLenum, GLuint);
typedef void (APIENTRY *avpPFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum, GLenum, GLenum, GLuint, GLint);
typedef void (APIENTRY *avpPFNGLGENERATEMIPMAPPROC)(GLenum);
typedef void (APIENTRY *avpPFNGLGENFRAMEBUFFERSPROC)(GLsizei, GLuint*);
typedef void (APIENTRY *avpPFNGLGENRENDERBUFFERSPROC)(GLsizei, GLuint*);
typedef void (APIENTRY *avpPFNGLRENDERBUFFERSTORAGEPROC)(GLenum, GLenum, GLsizei, GLsizei);
extern avpPFNGLBINDFRAMEBUFFERPROC pglBindFramebuffer;
extern avpPFNGLBINDRENDERBUFFERPROC pglBindRenderbuffer;
extern avpPFNGLCHECKFRAMEBUFFERSTATUSPROC pglCheckFramebufferStatus;
extern avpPFNGLDELETEFRAMEBUFFERSPROC pglDeleteFramebuffers;
extern avpPFNGLDELETERENDERBUFFERSPROC pglDeleteRenderbuffers;
extern avpPFNGLFRAMEBUFFERRENDERBUFFERPROC pglFramebufferRenderbuffer;
extern avpPFNGLFRAMEBUFFERTEXTURE2DPROC pglFramebufferTexture2D;
extern avpPFNGLGENERATEMIPMAPPROC pglGenerateMipmap;
extern avpPFNGLGENFRAMEBUFFERSPROC pglGenFramebuffers;
extern avpPFNGLGENRENDERBUFFERSPROC pglGenRenderbuffers;
extern avpPFNGLRENDERBUFFERSTORAGEPROC pglRenderbufferStorage;
extern PFNGLALPHAFUNCPROC pglAlphaFunc;
extern PFNGLBINDTEXTUREPROC pglBindTexture;
extern PFNGLBLENDFUNCPROC pglBlendFunc;
extern PFNGLCLEARPROC pglClear;
extern PFNGLCLEARCOLORPROC pglClearColor;
extern PFNGLCOLOR4FPROC pglColor4f;
extern PFNGLCOLORPOINTERPROC pglColorPointer;
extern PFNGLCULLFACEPROC pglCullFace;
extern PFNGLDELETETEXTURESPROC pglDeleteTextures;
extern PFNGLDEPTHFUNCPROC pglDepthFunc;
extern PFNGLDEPTHMASKPROC pglDepthMask;
extern PFNGLDEPTHRANGEPROC pglDepthRange;
extern PFNGLDISABLEPROC pglDisable;
extern PFNGLDISABLECLIENTSTATEPROC pglDisableClientState;
extern PFNGLDRAWELEMENTSPROC pglDrawElements;
extern PFNGLENABLEPROC pglEnable;
extern PFNGLENABLECLIENTSTATEPROC pglEnableClientState;
extern PFNGLFRONTFACEPROC pglFrontFace;
extern PFNGLGENTEXTURESPROC pglGenTextures;
extern PFNGLGETERRORPROC pglGetError;
extern PFNGLGETFLOATVPROC pglGetFloatv;
extern PFNGLGETINTEGERVPROC pglGetIntegerv;
extern PFNGLGETSTRINGPROC pglGetString;
extern PFNGLGETTEXPARAMETERFVPROC pglGetTexParameterfv;
extern PFNGLHINTPROC pglHint;
extern PFNGLPIXELSTOREIPROC pglPixelStorei;
extern PFNGLPOLYGONOFFSETPROC pglPolygonOffset;
extern PFNGLREADPIXELSPROC pglReadPixels;
extern PFNGLSHADEMODELPROC pglShadeModel;
extern PFNGLTEXCOORDPOINTERPROC pglTexCoordPointer;
extern PFNGLTEXENVFPROC pglTexEnvf;
extern PFNGLTEXENVFVPROC pglTexEnvfv;
extern PFNGLTEXENVIPROC pglTexEnvi;
extern PFNGLTEXIMAGE2DPROC pglTexImage2D;
extern PFNGLTEXPARAMETERFPROC pglTexParameterf;
extern PFNGLTEXPARAMETERIPROC pglTexParameteri;
extern PFNGLTEXSUBIMAGE2DPROC pglTexSubImage2D;
extern PFNGLVERTEXPOINTERPROC pglVertexPointer;
extern PFNGLVIEWPORTPROC pglViewport;
extern int ogl_have_multisample_filter_hint; extern int ogl_have_multisample_filter_hint;
extern int ogl_have_texture_filter_anisotropic; extern int ogl_have_texture_filter_anisotropic;
extern int ogl_have_framebuffer_object;
extern int ogl_use_multisample_filter_hint; extern int ogl_use_multisample_filter_hint;
extern int ogl_use_texture_filter_anisotropic; extern int ogl_use_texture_filter_anisotropic;
extern int ogl_use_framebuffer_object;
extern void load_ogl_functions(int mode); extern void load_ogl_functions(int mode);

17
src/openal.c
View file

@ -3,8 +3,13 @@
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
#if EMSCRIPTEN
#include <AL/al.h>
#include <AL/alc.h>
#else
#include "al.h" #include "al.h"
#include "alc.h" #include "alc.h"
#endif
#include "fixer.h" #include "fixer.h"
@ -19,7 +24,7 @@
#include "dynblock.h" #include "dynblock.h"
#include "stratdef.h" #include "stratdef.h"
#if defined( _MSC_VER ) #if defined( _MSC_VERx )
#include <AL/eax.h> #include <AL/eax.h>
#endif #endif
@ -47,7 +52,7 @@ static struct {
unsigned int env_index; unsigned int env_index;
} SoundConfig; } SoundConfig;
#if defined(_MSC_VER) #if defined(_MSC_VERx)
// EAX1.0 // EAX1.0
#define EAX_REVERBMIX_USEDISTANCE -1.0F #define EAX_REVERBMIX_USEDISTANCE -1.0F
@ -225,7 +230,7 @@ int PlatStartSoundSys()
exit(1); exit(1);
} }
#if defined(_MSC_VER) #if defined(_MSC_VERx)
EAX_pfPropSet = NULL; EAX_pfPropSet = NULL;
EAX_pfPropGet = NULL; EAX_pfPropGet = NULL;
@ -870,7 +875,7 @@ void PlatUpdatePlayer()
or[5] = -(float) ((Global_VDB_Ptr->VDB_Mat.mat32) / 65536.0F); or[5] = -(float) ((Global_VDB_Ptr->VDB_Mat.mat32) / 65536.0F);
} }
#warning VELOCITY AND/OR OPENAL SETUP IS IN WRONG UNITS #pragma message ("VELOCITY AND/OR OPENAL SETUP IS IN WRONG UNITS")
static int useVel = 0; static int useVel = 0;
if (useVel!=0&&(AvP.PlayerType == I_Alien && DopplerShiftIsOn && NormalFrameTime)) { if (useVel!=0&&(AvP.PlayerType == I_Alien && DopplerShiftIsOn && NormalFrameTime)) {
DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr; DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr;
@ -902,7 +907,7 @@ void PlatUpdatePlayer()
alListenerfv (AL_POSITION, pos); alListenerfv (AL_POSITION, pos);
} }
#if defined( _MSC_VER ) #if defined( _MSC_VERx )
if( SoundConfig.reverb_changed ) { if( SoundConfig.reverb_changed ) {
// TODO: reverb handling // TODO: reverb handling
} }
@ -915,7 +920,7 @@ void PlatSetEnviroment(unsigned int env_index, float reverb_mix)
fprintf(stderr, "OPENAL: PlatSetEnvironment(%d, %f)\n", env_index, reverb_mix); fprintf(stderr, "OPENAL: PlatSetEnvironment(%d, %f)\n", env_index, reverb_mix);
#endif #endif
#if defined( _MSC_VER ) #if defined( _MSC_VERx )
if( SoundConfig.env_index != env_index ) { if( SoundConfig.env_index != env_index ) {
// TODO: support the custom plain reverb // TODO: support the custom plain reverb

1070
src/opengl.c
View file

File diff suppressed because it is too large Load diff

26
src/opengl.h
View file

@ -3,7 +3,31 @@
#include "kshape.h" #include "kshape.h"
void InitOpenGL();
#define OPENGL_VERTEX_ATTRIB_INDEX 0
#define OPENGL_TEXCOORD_ATTRIB_INDEX 1
#define OPENGL_COLOR0_ATTRIB_INDEX 2
#define OPENGL_COLOR1_ATTRIB_INDEX 3
#define OPENGL_VERTEX_ATTRIB_BITINDEX (1 << OPENGL_VERTEX_ATTRIB_INDEX)
#define OPENGL_TEXCOORD_ATTRIB_BITINDEX (1 << OPENGL_TEXCOORD_ATTRIB_INDEX)
#define OPENGL_COLOR0_ATTRIB_BITINDEX (1 << OPENGL_COLOR0_ATTRIB_INDEX)
#define OPENGL_COLOR1_ATTRIB_BITINDEX (1 << OPENGL_COLOR1_ATTRIB_INDEX)
enum AVP_SHADER_PROGRAM {
AVP_SHADER_PROGRAM_DEFAULT,
AVP_SHADER_PROGRAM_NO_SECONDARY,
AVP_SHADER_PROGRAM_NO_TEXTURE,
AVP_SHADER_PROGRAM_NO_DISCARD,
AVP_SHADER_PROGRAM_NO_SECONDARY_NO_DISCARD,
AVP_SHADER_PROGRAM_NO_COLOR_NO_DISCARD,
AVP_SHADER_PROGRAM_MAX
};
void SelectProgram(enum AVP_SHADER_PROGRAM program);
void DrawFullscreenTexture(int texureObject);
void InitOpenGL(int firsttime);
void ThisFramesRenderingHasBegun(); void ThisFramesRenderingHasBegun();
void ThisFramesRenderingHasFinished(); void ThisFramesRenderingHasFinished();
void D3D_SkyPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVerticesPtr); void D3D_SkyPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVerticesPtr);

29
src/unaligned.h Normal file
View file

@ -0,0 +1,29 @@
#ifndef UNALIGNED_H
#define UNALIGNED_H
// Anything using these types is not alignment and endian clean.
#if EMSCRIPTEN
#include <emscripten.h>
typedef emscripten_align1_short unaligned_s16;
typedef emscripten_align1_int unaligned_s32;
typedef emscripten_align1_short unaligned_u16;
typedef emscripten_align1_int unaligned_u32;
typedef emscripten_align1_float unaligned_f32;
typedef emscripten_align1_double unaligned_f64;
#else
#include <stdint.h>
typedef int16_t unaligned_s16;
typedef int32_t unaligned_s32;
typedef uint16_t unaligned_u16;
typedef uint32_t unaligned_u32;
typedef float unaligned_f32;
typedef double unaligned_f64;
#endif
#endif

3
src/win95/aw.h
View file

@ -19,6 +19,9 @@ typedef struct DIRECTDRAWSURFACE
float RecipW; float RecipW;
float RecipH; float RecipH;
int hasAlpha;
int hasChroma;
int filter; int filter;
} DIRECTDRAWSURFACE; } DIRECTDRAWSURFACE;

16
src/win95/awtexld.cpp
View file

@ -145,8 +145,7 @@ namespace AwTl
DWORD memFlag; DWORD memFlag;
void * ddP; void * ddP;
} } driverDesc;
driverDesc;
/*************************************************************************/ /*************************************************************************/
/* Class used to hold all the parameters for the CreateTexture functions */ /* Class used to hold all the parameters for the CreateTexture functions */
@ -496,6 +495,9 @@ void AwBackupTexture::ChoosePixelFormat(AwTl::CreateTextureParms const & _parmsR
#endif #endif
/* Just convert the texture to 32bpp */ /* Just convert the texture to 32bpp */
// may want to support paletted textures
// at some point; at which point, should
// push texture conversion into the opengl layer
pixelFormat.palettizedB = 0; pixelFormat.palettizedB = 0;
pixelFormat.alphaB = 1; pixelFormat.alphaB = 1;
@ -540,7 +542,15 @@ AwTl::SurfUnion AwBackupTexture::CreateTexture(AwTl::CreateTextureParms const &
fprintf(stderr, "AwBackupTexture::CreateTexture - chroma\n"); fprintf(stderr, "AwBackupTexture::CreateTexture - chroma\n");
} }
if (pixelFormat.texB && m_bTranspMask) {
//fprintf(stderr, "AwBackupTexture::CreateTexture - transparency\n");
}
// convert asset to 32-bit rgba // convert asset to 32-bit rgba
// may want to support paletted textures
// at some point; at which point, should
// push texture conversion into the opengl layer
unsigned char *buf = (unsigned char *)malloc(m_nWidth * m_nHeight * 4); unsigned char *buf = (unsigned char *)malloc(m_nWidth * m_nHeight * 4);
Colour * paletteP = m_nPaletteSize ? GetPalette() : NULL; Colour * paletteP = m_nPaletteSize ? GetPalette() : NULL;
@ -591,6 +601,8 @@ AwTl::SurfUnion AwBackupTexture::CreateTexture(AwTl::CreateTextureParms const &
Tex->w = m_nWidth; Tex->w = m_nWidth;
Tex->h = m_nHeight; Tex->h = m_nHeight;
Tex->hasAlpha = m_bTranspMask;
Tex->hasChroma = m_fFlags & AW_TLF_CHROMAKEY;
if (pixelFormat.texB) { if (pixelFormat.texB) {
CreateOGLTexture(Tex, buf); CreateOGLTexture(Tex, buf);

5
src/win95/db.c
View file

@ -387,6 +387,10 @@ void db_print_fired(int x, int y, const char *strP)
*/ */
void db_log_fired(const char *strP) void db_log_fired(const char *strP)
{ {
#if EMSCRIPTEN
printf("%s\n", strP);
return;
#else
/* Have we intialised the file? */ /* Have we intialised the file? */
if(!InitialisedLog) db_log_init(); if(!InitialisedLog) db_log_init();
{ {
@ -398,6 +402,7 @@ void db_log_fired(const char *strP)
fprintf(fP, "%s\n", strP); fprintf(fP, "%s\n", strP);
fclose(fP); fclose(fP);
} }
#endif
} }
void db_log_init(void) void db_log_init(void)

22
src/win95/iff.hpp
View file

@ -158,16 +158,19 @@ namespace IFF
UBYTE b; UBYTE b;
}; };
union ID struct ID
{ {
UINT32 m_nID; UINT32 m_nID;
char m_sID[4];
inline ID(){} inline ID() : m_nID(0) {}
inline ID(char const * pszID) { m_nID = *reinterpret_cast<UINT32 const *>(pszID); } inline ID(char const * pszID) {
m_nID = (pszID[0] << 0)
| (pszID[1] << 8)
| (pszID[2] << 16)
| (pszID[3] << 24);
}
inline ID(UINT32 nID) : m_nID(nID) {} inline ID(UINT32 nID) : m_nID(nID) {}
inline operator UINT32 () const { return m_nID; } inline operator UINT32 () const { return m_nID; }
inline operator char const * () const { return &m_sID[0]; }
inline bool operator == (ID const & rId) const { return !m_nID || !rId.m_nID || m_nID == rId.m_nID; } inline bool operator == (ID const & rId) const { return !m_nID || !rId.m_nID || m_nID == rId.m_nID; }
inline bool operator != (ID const & rId) const { return ! operator == (rId); } inline bool operator != (ID const & rId) const { return ! operator == (rId); }
inline bool operator ! () const { return !m_nID; } inline bool operator ! () const { return !m_nID; }
@ -717,8 +720,13 @@ namespace IFF
m_nBytesRemaining -= 4; m_nBytesRemaining -= 4;
if (m_nBytesRemaining >= 0) if (m_nBytesRemaining >= 0)
{ {
// cast pointer to pointer to 4 byte data type to force 4 byte 'fast' read
::MediaRead(m_pMedium, reinterpret_cast<UINT32 *>(&n.m_sID[0])); UBYTE b0, b1, b2, b3;
::MediaRead(m_pMedium, &b0);
::MediaRead(m_pMedium, &b1);
::MediaRead(m_pMedium, &b2);
::MediaRead(m_pMedium, &b3);
n.m_nID = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
if (m_pMedium->m_fError) m_bError = true; if (m_pMedium->m_fError) m_bError = true;
} }
else m_bError = true; else m_bError = true;

172
src/win95/media.hpp
View file

@ -4,24 +4,14 @@
#include <stdio.h> #include <stdio.h>
#include <limits.h> #include <limits.h>
#include <string.h> #include <string.h>
class MediaMedium;
// use this to read in simple data types // type names that do not conflcit with anything else
// note especially that if the size of TYPE is greater than the typedef signed char S8;
// default buffer size, then the operation will fail typedef unsigned char U8;
// and the virtual end of file error flag will be set typedef signed short int S16;
// - use ReadBlock instead typedef unsigned short int U16;
template <class TYPE> typedef signed int S32;
void MediaRead(MediaMedium * pThis, TYPE * p); typedef unsigned int U32;
// use this to write simple data types
// note especially that if the size of TYPE is greater than the
// default buffer size, then the operation will fail
// and the virtual end of file error flag will be set
// - use WriteBlock instead
template <class TYPE>
void MediaWrite(MediaMedium * pThis, TYPE d);
class MediaMedium class MediaMedium
{ {
@ -270,62 +260,13 @@ class MediaMedium
virtual void DoSetPos(unsigned nPos) = 0; virtual void DoSetPos(unsigned nPos) = 0;
friend class MediaSection; friend class MediaSection;
friend class _Media_CompilerHack;
};
class _Media_CompilerHack friend void MediaRead(MediaMedium * pThis, S8 * p);
{ friend void MediaRead(MediaMedium * pThis, U8 * p);
public: friend void MediaRead(MediaMedium * pThis, S16 * p);
template <class TYPE> friend void MediaRead(MediaMedium * pThis, U16 * p);
static inline void MediaRead(MediaMedium * pThis, TYPE * p) friend void MediaRead(MediaMedium * pThis, S32 * p);
{ friend void MediaRead(MediaMedium * pThis, U32 * p);
if (pThis->m_nReadBufPos + sizeof(TYPE) <= pThis->m_nBufSize)
{
*p = *reinterpret_cast<TYPE const *>(static_cast<char const *>(pThis->m_pReadBuffer) + pThis->m_nReadBufPos/sizeof(char));
pThis->m_nReadBufPos += sizeof(TYPE);
}
else
{
pThis->Flush();
pThis->m_pReadBuffer = pThis->GetReadBuffer(&pThis->m_nBufSize,pThis->m_nDefBufSize);
if (sizeof(TYPE) <= pThis->m_nBufSize)
{
*p = *static_cast<TYPE const *>(pThis->m_pReadBuffer);
pThis->m_nReadBufPos = sizeof(TYPE);
}
else
{
pThis->m_fError |= MediaMedium::MME_VEOFMET;
}
}
}
template <class TYPE>
static inline void MediaWrite(MediaMedium * pThis, TYPE d)
{
if (pThis->m_nWriteBufPos + sizeof(TYPE) <= pThis->m_nBufSize)
{
*reinterpret_cast<TYPE *>(static_cast<char *>(pThis->m_pWriteBuffer) + pThis->m_nWriteBufPos/sizeof(char)) = d;
pThis->m_nWriteBufPos += sizeof(TYPE);
}
else
{
pThis->Flush();
pThis->m_pWriteBuffer = pThis->GetWriteBuffer(&pThis->m_nBufSize,pThis->m_nDefBufSize);
if (sizeof(TYPE) <= pThis->m_nBufSize)
{
*static_cast<TYPE *>(pThis->m_pWriteBuffer) = d;
pThis->m_nWriteBufPos = sizeof(TYPE);
}
else
{
pThis->m_fError |= MediaMedium::MME_VEOFMET;
}
}
}
}; };
// use this to read in simple data types // use this to read in simple data types
@ -333,21 +274,86 @@ class _Media_CompilerHack
// default buffer size, then the operation will fail // default buffer size, then the operation will fail
// and the virtual end of file error flag will be set // and the virtual end of file error flag will be set
// - use ReadBlock instead // - use ReadBlock instead
template <class TYPE> inline void MediaRead(MediaMedium * pThis, S8 * p)
inline void MediaRead(MediaMedium * pThis, TYPE * p)
{ {
_Media_CompilerHack::MediaRead(pThis,p); if (pThis->m_nReadBufPos + sizeof(S8) <= pThis->m_nBufSize)
{
*p = static_cast<S8 const *>(pThis->m_pReadBuffer)[pThis->m_nReadBufPos];
pThis->m_nReadBufPos += sizeof(S8);
}
else
{
pThis->Flush();
pThis->m_pReadBuffer = pThis->GetReadBuffer(&pThis->m_nBufSize,pThis->m_nDefBufSize);
if (sizeof(S8) <= pThis->m_nBufSize)
{
*p = *static_cast<S8 const *>(pThis->m_pReadBuffer);
pThis->m_nReadBufPos = sizeof(S8);
}
else
{
pThis->m_fError |= MediaMedium::MME_VEOFMET;
}
}
} }
// use this to write simple data types inline void MediaRead(MediaMedium * pThis, U8 * p)
// note especially that if the size of TYPE is greater than the
// default buffer size, then the operation will fail
// and the virtual end of file error flag will be set
// - use WriteBlock instead
template <class TYPE>
inline void MediaWrite(MediaMedium * pThis, TYPE d)
{ {
_Media_CompilerHack::MediaWrite(pThis,d); if (pThis->m_nReadBufPos + sizeof(U8) <= pThis->m_nBufSize)
{
*p = static_cast<U8 const *>(pThis->m_pReadBuffer)[pThis->m_nReadBufPos];
pThis->m_nReadBufPos += sizeof(U8);
}
else
{
pThis->Flush();
pThis->m_pReadBuffer = pThis->GetReadBuffer(&pThis->m_nBufSize,pThis->m_nDefBufSize);
if (sizeof(U8) <= pThis->m_nBufSize)
{
*p = *static_cast<U8 const *>(pThis->m_pReadBuffer);
pThis->m_nReadBufPos = sizeof(U8);
}
else
{
pThis->m_fError |= MediaMedium::MME_VEOFMET;
}
}
}
inline void MediaRead(MediaMedium * pThis, S16 * p)
{
S8 b0, b1;
::MediaRead(pThis, &b0);
::MediaRead(pThis, &b1);
*p = (b0 << 0) | (b1 << 8);
}
inline void MediaRead(MediaMedium * pThis, U16 * p)
{
U8 b0, b1;
::MediaRead(pThis, &b0);
::MediaRead(pThis, &b1);
*p = (b0 << 0) | (b1 << 8);
}
inline void MediaRead(MediaMedium * pThis, S32 * p)
{
S8 b0, b1, b2, b3;
::MediaRead(pThis, &b0);
::MediaRead(pThis, &b1);
::MediaRead(pThis, &b2);
::MediaRead(pThis, &b3);
*p = (b0 << 0) | (b1 << 8) | (b2 << 16) | (b3 << 24);
}
inline void MediaRead(MediaMedium * pThis, U32 * p)
{
U8 b0, b1, b2, b3;
::MediaRead(pThis, &b0);
::MediaRead(pThis, &b1);
::MediaRead(pThis, &b2);
::MediaRead(pThis, &b3);
*p = (b0 << 0) | (b1 << 8) | (b2 << 16) | (b3 << 24);
} }
#ifdef _MEDIA_WIN_TARGET #ifdef _MEDIA_WIN_TARGET

6
src/win95/shpchunk.cpp
View file

@ -1,5 +1,5 @@
#include <math.h> #include <math.h>
#include "unaligned.h"
#include "chunk.hpp" #include "chunk.hpp"
#include "chnktype.hpp" #include "chnktype.hpp"
#include "shpchunk.hpp" #include "shpchunk.hpp"
@ -1610,9 +1610,9 @@ Shape_External_Filename_Chunk::Shape_External_Filename_Chunk(Chunk_With_Children
Shape_External_Filename_Chunk::Shape_External_Filename_Chunk (Chunk_With_Children * parent, const char *fdata, size_t /*fsize*/) Shape_External_Filename_Chunk::Shape_External_Filename_Chunk (Chunk_With_Children * parent, const char *fdata, size_t /*fsize*/)
: Chunk (parent, "SHPEXTFN") : Chunk (parent, "SHPEXTFN")
{ {
rescale = *((double *) fdata); rescale = *((unaligned_f64 *) fdata);
fdata += 8; fdata += 8;
version_no = *((int *) fdata); version_no = *((unaligned_s32 *) fdata);
fdata += 4; fdata += 4;
file_name = new char [strlen(fdata)+1]; file_name = new char [strlen(fdata)+1];
strcpy (file_name, fdata); strcpy (file_name, fdata);

6
src/winfiles.c
View file

@ -762,10 +762,8 @@ static const char* GetGlobalDirectory(const char* argv0)
/* /*
Game-specific initialization Game-specific initialization
*/ */
extern "C" { extern char const *SecondTex_Directory;
extern char const *SecondTex_Directory; extern char const *SecondSoundDir;
extern char const *SecondSoundDir;
}
void InitGameDirectories(char *argv0) void InitGameDirectories(char *argv0)
{ {