0ct0pu5/wesnoth
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Import SDL_gpu sources.

Browse source 
NOTE: no SCons build yet.
This commit is contained in:
Boldizsár Lipka 2014-06-27 10:55:20 +02:00
parent 050235c439
commit 9cce856aa0
39 changed files with 54345 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/CMakeLists.txt
View file

@ -52,6 +52,9 @@ if(USE_ANA_NETWORK)
add_subdirectory(ana/src)
endif(USE_ANA_NETWORK)
message(STATUS "Configuring SDL_gpu...")
add_subdirectory(SDL_gpu)
# needed to get include paths in the subfolders correct
include_directories( ${CMAKE_SOURCE_DIR}/src/ )
# needed to have the generated config.h used, too
@ -72,6 +75,7 @@ if(MSVC)
${SDLMAIN_LIBRARY}
${LIBINTL_LIBRARY}
ws2_32.lib
SDL_gpu.lib
)
else(MSVC)
set(common-external-libs
@ -80,6 +84,7 @@ else(MSVC)
${Boost_REGEX_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${LIBINTL_LIBRARIES}
SDL_gpu
)
endif(MSVC)

88
src/SDL_gpu/CMake_scripts/FindFFMPEG.cmake Normal file
View file

@ -0,0 +1,88 @@
# - Try to find ffmpeg libraries (libavcodec, libavformat and libavutil)
# Once done this will define
#
# FFMPEG_FOUND - system has ffmpeg or libav
# FFMPEG_INCLUDE_DIR - the ffmpeg include directory
# FFMPEG_LIBRARIES - Link these to use ffmpeg
# FFMPEG_LIBAVCODEC
# FFMPEG_LIBAVFORMAT
# FFMPEG_LIBAVUTIL
# FFMPEG_LIBSWSCALE
#
# Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
# Modified for other libraries by Lasse Kärkkäinen <tronic>
# Modified for Hedgewars by Stepik777
# Modified for SDL_gpu by Jonathan Dearborn
#
# Redistribution and use is allowed according to the terms of the New
# BSD license.
#
if (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
# in cache already
set(FFMPEG_FOUND TRUE)
else (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
# use pkg-config to get the directories and then use these values
# in the FIND_PATH() and FIND_LIBRARY() calls
find_package(PkgConfig)
if (PKG_CONFIG_FOUND)
pkg_check_modules(_FFMPEG_AVCODEC libavcodec)
pkg_check_modules(_FFMPEG_AVFORMAT libavformat)
pkg_check_modules(_FFMPEG_AVUTIL libavutil)
pkg_check_modules(_FFMPEG_SWSCALE libswscale)
endif (PKG_CONFIG_FOUND)
find_path(FFMPEG_AVCODEC_INCLUDE_DIR
NAMES libavcodec/avcodec.h
PATHS ${_FFMPEG_AVCODEC_INCLUDE_DIRS} /usr/include /usr/local/include /opt/local/include /sw/include
PATH_SUFFIXES ffmpeg libav
)
find_library(FFMPEG_LIBAVCODEC
NAMES avcodec
PATHS ${_FFMPEG_AVCODEC_LIBRARY_DIRS} /usr/lib /usr/local/lib /opt/local/lib /sw/lib
)
find_library(FFMPEG_LIBAVFORMAT
NAMES avformat
PATHS ${_FFMPEG_AVFORMAT_LIBRARY_DIRS} /usr/lib /usr/local/lib /opt/local/lib /sw/lib
)
find_library(FFMPEG_LIBAVUTIL
NAMES avutil
PATHS ${_FFMPEG_AVUTIL_LIBRARY_DIRS} /usr/lib /usr/local/lib /opt/local/lib /sw/lib
)
find_library(FFMPEG_LIBSWSCALE
NAMES swscale
PATHS ${_FFMPEG_SWSCALE_LIBRARY_DIRS} /usr/lib /usr/local/lib /opt/local/lib /sw/lib
)
if (FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVFORMAT)
set(FFMPEG_FOUND TRUE)
endif()
if (FFMPEG_FOUND)
set(FFMPEG_INCLUDE_DIR ${FFMPEG_AVCODEC_INCLUDE_DIR})
set(FFMPEG_LIBRARIES
${FFMPEG_LIBAVCODEC}
${FFMPEG_LIBAVFORMAT}
${FFMPEG_LIBAVUTIL}
${FFMPEG_LIBSWSCALE}
)
endif (FFMPEG_FOUND)
if (FFMPEG_FOUND)
if (NOT FFMPEG_FIND_QUIETLY)
message(STATUS "Found FFMPEG or Libav: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}")
endif (NOT FFMPEG_FIND_QUIETLY)
else (FFMPEG_FOUND)
if (FFMPEG_FIND_REQUIRED)
message(FATAL_ERROR "Could not find libavcodec or libavformat or libavutil")
endif (FFMPEG_FIND_REQUIRED)
endif (FFMPEG_FOUND)
endif (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)

100
src/SDL_gpu/CMake_scripts/FindOpenGLES.cmake Normal file
View file

@ -0,0 +1,100 @@
#-------------------------------------------------------------------
# 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
include(FindPkgMacros)
IF (WIN32)
IF(0) # Disabled, untill further testing
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 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 library for win32")
ENDIF(BORLAND)
ENDIF (CYGWIN)
ENDIF()
ELSE (WIN32)
IF (APPLE)
create_search_paths(/Developer/Platforms)
findpkg_framework(OpenGLES)
set(OPENGLES_gl_LIBRARY "-framework OpenGLES")
ELSE(APPLE)
IF(0) # Disabled, untill further testing
FIND_PATH(OPENGLES_INCLUDE_DIR GLES/gl.h
/usr/openwin/share/include
/opt/graphics/OpenGL/include /usr/X11R6/include
/usr/include
)
FIND_LIBRARY(OPENGLES_gl_LIBRARY
NAMES GLES_CM
PATHS /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.
# It's not true on OSX.
IF (OPENGLES_gl_LIBRARY)
IF(NOT X11_FOUND)
INCLUDE(FindX11)
ENDIF(NOT X11_FOUND)
IF (X11_FOUND)
IF (NOT APPLE)
SET (OPENGLES_LIBRARIES ${X11_LIBRARIES})
ENDIF (NOT APPLE)
ENDIF (X11_FOUND)
ENDIF (OPENGLES_gl_LIBRARY)
ENDIF()
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
)

142
src/SDL_gpu/CMake_scripts/FindPkgMacros.cmake Normal file
View file

@ -0,0 +1,142 @@
#-------------------------------------------------------------------
# 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.
#-------------------------------------------------------------------
##################################################################
# Provides some common functionality for the FindPackage modules
##################################################################
# Begin processing of package
macro(findpkg_begin PREFIX)
if (NOT ${PREFIX}_FIND_QUIETLY)
message(STATUS "Looking for ${PREFIX}...")
endif ()
endmacro(findpkg_begin)
# Display a status message unless FIND_QUIETLY is set
macro(pkg_message PREFIX)
if (NOT ${PREFIX}_FIND_QUIETLY)
message(STATUS ${ARGN})
endif ()
endmacro(pkg_message)
# Get environment variable, define it as ENV_$var and make sure backslashes are converted to forward slashes
macro(getenv_path VAR)
set(ENV_${VAR} $ENV{${VAR}})
# replace won't work if var is blank
if (ENV_${VAR})
string( REGEX REPLACE "\\\\" "/" ENV_${VAR} ${ENV_${VAR}} )
endif ()
endmacro(getenv_path)
# Construct search paths for includes and libraries from a PREFIX_PATH
macro(create_search_paths PREFIX)
foreach(dir ${${PREFIX}_PREFIX_PATH})
set(${PREFIX}_INC_SEARCH_PATH ${${PREFIX}_INC_SEARCH_PATH}
${dir}/include ${dir}/include/${PREFIX} ${dir}/Headers)
set(${PREFIX}_LIB_SEARCH_PATH ${${PREFIX}_LIB_SEARCH_PATH}
${dir}/lib ${dir}/lib/${PREFIX} ${dir}/Libs)
endforeach(dir)
set(${PREFIX}_FRAMEWORK_SEARCH_PATH ${${PREFIX}_PREFIX_PATH})
endmacro(create_search_paths)
# clear cache variables if a certain variable changed
macro(clear_if_changed TESTVAR)
# test against internal check variable
if (NOT "${${TESTVAR}}" STREQUAL "${${TESTVAR}_INT_CHECK}")
message(STATUS "${TESTVAR} changed.")
foreach(var ${ARGN})
set(${var} "NOTFOUND" CACHE STRING "x" FORCE)
endforeach(var)
endif ()
set(${TESTVAR}_INT_CHECK ${${TESTVAR}} CACHE INTERNAL "x" FORCE)
endmacro(clear_if_changed)
# Try to get some hints from pkg-config, if available
macro(use_pkgconfig PREFIX PKGNAME)
find_package(PkgConfig)
if (PKG_CONFIG_FOUND)
pkg_check_modules(${PREFIX} ${PKGNAME})
endif ()
endmacro (use_pkgconfig)
# Couple a set of release AND debug libraries (or frameworks)
macro(make_library_set PREFIX)
if (${PREFIX}_FWK)
set(${PREFIX} ${${PREFIX}_FWK})
elseif (${PREFIX}_REL AND ${PREFIX}_DBG)
set(${PREFIX} optimized ${${PREFIX}_REL} debug ${${PREFIX}_DBG})
elseif (${PREFIX}_REL)
set(${PREFIX} ${${PREFIX}_REL})
elseif (${PREFIX}_DBG)
set(${PREFIX} ${${PREFIX}_DBG})
endif ()
endmacro(make_library_set)
# Generate debug names from given release names
macro(get_debug_names PREFIX)
foreach(i ${${PREFIX}})
set(${PREFIX}_DBG ${${PREFIX}_DBG} ${i}d ${i}D ${i}_d ${i}_D ${i}_debug ${i})
endforeach(i)
endmacro(get_debug_names)
# Add the parent dir from DIR to VAR
macro(add_parent_dir VAR DIR)
get_filename_component(${DIR}_TEMP "${${DIR}}/.." ABSOLUTE)
set(${VAR} ${${VAR}} ${${DIR}_TEMP})
endmacro(add_parent_dir)
# Do the final processing for the package find.
macro(findpkg_finish PREFIX)
# skip if already processed during this run
if (NOT ${PREFIX}_FOUND)
if (${PREFIX}_INCLUDE_DIR AND ${PREFIX}_LIBRARY)
set(${PREFIX}_FOUND TRUE)
set(${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIR})
set(${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARY})
if (NOT ${PREFIX}_FIND_QUIETLY)
message(STATUS "Found ${PREFIX}: ${${PREFIX}_LIBRARIES}")
endif ()
else ()
if (NOT ${PREFIX}_FIND_QUIETLY)
message(STATUS "Could not locate ${PREFIX}")
endif ()
if (${PREFIX}_FIND_REQUIRED)
message(FATAL_ERROR "Required library ${PREFIX} not found! Install the library (including dev packages) and try again. If the library is already installed, set the missing variables manually in cmake.")
endif ()
endif ()
mark_as_advanced(${PREFIX}_INCLUDE_DIR ${PREFIX}_LIBRARY ${PREFIX}_LIBRARY_REL ${PREFIX}_LIBRARY_DBG ${PREFIX}_LIBRARY_FWK)
endif ()
endmacro(findpkg_finish)
# Slightly customised framework finder
MACRO(findpkg_framework fwk)
IF(APPLE)
SET(${fwk}_FRAMEWORK_PATH
${${fwk}_FRAMEWORK_SEARCH_PATH}
${CMAKE_FRAMEWORK_PATH}
~/Library/Frameworks
/Library/Frameworks
/System/Library/Frameworks
/Network/Library/Frameworks
/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS3.0.sdk/System/Library/Frameworks/
)
FOREACH(dir ${${fwk}_FRAMEWORK_PATH})
SET(fwkpath ${dir}/${fwk}.framework)
IF(EXISTS ${fwkpath})
SET(${fwk}_FRAMEWORK_INCLUDES ${${fwk}_FRAMEWORK_INCLUDES}
${fwkpath}/Headers ${fwkpath}/PrivateHeaders)
if (NOT ${fwk}_LIBRARY_FWK)
SET(${fwk}_LIBRARY_FWK "-framework ${fwk}")
endif ()
ENDIF(EXISTS ${fwkpath})
ENDFOREACH(dir)
ENDIF(APPLE)
ENDMACRO(findpkg_framework)

180
src/SDL_gpu/CMake_scripts/FindSDL2.cmake Normal file
View file

@ -0,0 +1,180 @@
# Locate SDL2 library
# This module defines
# SDL2_LIBRARY, the name of the library to link against
# SDL2_FOUND, if false, do not try to link to SDL2
# SDL2_INCLUDE_DIR, where to find SDL.h
#
# This module responds to the the flag:
# SDL2_BUILDING_LIBRARY
# If this is defined, then no SDL2_main will be linked in because
# only applications need main().
# Otherwise, it is assumed you are building an application and this
# module will attempt to locate and set the the proper link flags
# as part of the returned SDL2_LIBRARY variable.
#
# Don't forget to include SDL2main.h and SDL2main.m your project for the
# OS X framework based version. (Other versions link to -lSDL2main which
# this module will try to find on your behalf.) Also for OS X, this
# module will automatically add the -framework Cocoa on your behalf.
#
#
# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
# as appropriate. These values are used to generate the final SDL2_LIBRARY
# variable, but when these values are unset, SDL2_LIBRARY does not get created.
#
#
# $SDL2DIR is an environment variable that would
# correspond to the ./configure --prefix=$SDL2DIR
# used in building SDL2.
# l.e.galup 9-20-02
#
# Modified by Eric Wing.
# Added code to assist with automated building by using environmental variables
# and providing a more controlled/consistent search behavior.
# Added new modifications to recognize OS X frameworks and
# additional Unix paths (FreeBSD, etc).
# Also corrected the header search path to follow "proper" SDL2 guidelines.
# Added a search for SDL2main which is needed by some platforms.
# Added a search for threads which is needed by some platforms.
# Added needed compile switches for MinGW.
#
# On OSX, this will prefer the Framework version (if found) over others.
# People will have to manually change the cache values of
# SDL2_LIBRARY to override this selection or set the CMake environment
# CMAKE_INCLUDE_PATH to modify the search paths.
#
# Note that the header path has changed from SDL2/SDL.h to just SDL.h
# This needed to change because "proper" SDL2 convention
# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
# reasons because not all systems place things in SDL2/ (see FreeBSD).
#
# Ported by Johnny Patterson. This is a literal port for SDL2 of the FindSDL.cmake
# module with the minor edit of changing "SDL" to "SDL2" where necessary. This
# was not created for redistribution, and exists temporarily pending official
# SDL2 CMake modules.
#=============================================================================
# Copyright 2003-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
FIND_PATH(SDL2_INCLUDE_DIR SDL.h
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES include/SDL2 include
PATHS
~/Library/Frameworks
/Library/Frameworks
/usr/local/include/SDL2
/usr/include/SDL2
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
)
#MESSAGE("SDL2_INCLUDE_DIR is ${SDL2_INCLUDE_DIR}")
FIND_LIBRARY(SDL2_LIBRARY_TEMP
NAMES SDL2
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES lib64 lib
PATHS
/sw
/opt/local
/opt/csw
/opt
)
#MESSAGE("SDL2_LIBRARY_TEMP is ${SDL2_LIBRARY_TEMP}")
IF(NOT SDL2_BUILDING_LIBRARY)
IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
# Non-OS X framework versions expect you to also dynamically link to
# SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
# seem to provide SDL2main for compatibility even though they don't
# necessarily need it.
FIND_LIBRARY(SDL2MAIN_LIBRARY
NAMES SDL2main
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES lib64 lib
PATHS
/sw
/opt/local
/opt/csw
/opt
)
ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
ENDIF(NOT SDL2_BUILDING_LIBRARY)
# SDL2 may require threads on your system.
# The Apple build may not need an explicit flag because one of the
# frameworks may already provide it.
# But for non-OSX systems, I will use the CMake Threads package.
IF(NOT APPLE)
FIND_PACKAGE(Threads)
ENDIF(NOT APPLE)
# MinGW needs an additional library, mwindows
# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
# (Actually on second look, I think it only needs one of the m* libraries.)
IF(MINGW)
SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
ENDIF(MINGW)
SET(SDL2_FOUND "NO")
IF(SDL2_LIBRARY_TEMP)
# For SDL2main
IF(NOT SDL2_BUILDING_LIBRARY)
IF(SDL2MAIN_LIBRARY)
SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
ENDIF(SDL2MAIN_LIBRARY)
ENDIF(NOT SDL2_BUILDING_LIBRARY)
# For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
# CMake doesn't display the -framework Cocoa string in the UI even
# though it actually is there if I modify a pre-used variable.
# I think it has something to do with the CACHE STRING.
# So I use a temporary variable until the end so I can set the
# "real" variable in one-shot.
IF(APPLE)
SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
ENDIF(APPLE)
# For threads, as mentioned Apple doesn't need this.
# In fact, there seems to be a problem if I used the Threads package
# and try using this line, so I'm just skipping it entirely for OS X.
IF(NOT APPLE)
SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
ENDIF(NOT APPLE)
# For MinGW library
IF(MINGW)
SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
ENDIF(MINGW)
# Set the final string here so the GUI reflects the final state.
SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
# Set the temp variable to INTERNAL so it is not seen in the CMake GUI
SET(SDL2_LIBRARY_TEMP "${SDL2_LIBRARY_TEMP}" CACHE INTERNAL "")
SET(SDL2_FOUND "YES")
ENDIF(SDL2_LIBRARY_TEMP)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2
REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)

1781
src/SDL_gpu/Doxyfile Normal file
View file

File diff suppressed because it is too large Load diff

1
src/SDL_gpu/README-wesnoth Normal file
View file

@ -0,0 +1 @@
This directory includes the source code of the SDL_gpu library. It doesn't include the sources for the demos or the tools found in the original source tree. The CMake recipe in the top directory (where this file is located) was modified, when updating the SDL_gpu sources make sure not to overwrite it.

65
src/SDL_gpu/README.txt Normal file
View file

@ -0,0 +1,65 @@
SDL_gpu, a library for making hardware-accelerated 2D graphics easy.
by Jonathan Dearborn
SDL_gpu is licensed under the terms of the MIT License.
See LICENSE.txt for details of the usage license granted to you for this code.
=============
LATEST SOURCE
=============
SDL_gpu is hosted on Google Code (http://code.google.com/p/sdl-gpu). You can check out the latest version of the source code with Subversion:
svn checkout http://sdl-gpu.googlecode.com/svn/trunk/ sdl-gpu
To check out everything, including the pre-generated documentation:
svn checkout http://sdl-gpu.googlecode.com/svn/ sdl-gpu
For just the current library code, use:
svn checkout http://sdl-gpu.googlecode.com/svn/trunk/ sdl-gpu
============
DEPENDENCIES
============
SDL 1.2 or SDL 2.0 (www.libsdl.org)
A rendering backend
Currently implemented: OpenGL 1.1, OpenGL 2.0, OpenGL 3.0, OpenGL ES 1.1, OpenGL ES 2.0
========
BUILDING
========
SDL_gpu uses CMake (www.cmake.org) to coordinate the library build process. CMake is available as a GUI program or on the command line.
For Linux/UNIX systems, run CMake in the base directory:
cmake -G "Unix Makefiles"
make
sudo make install
For Linux/UNIX systems, changing the default installation directory can be done like so:
cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX=/usr
For Windows systems, you can use cmake-gui and select appropriate options in there (warning: cmake-gui is messy!).
===================
INCLUDING / LINKING
===================
Add the include for SDL_gpu.h to your sources. Link to SDL_gpu (libSDL_gpu.a) or SDL2_gpu (if you use SDL2).
=============
DOCUMENTATION
=============
Documentation is automatically generated with Doxygen (http://sourceforge.net/projects/doxygen).
Pre-generated documentation can be found in the repository's base documentation directory.

28
src/SDL_gpu/SDL_gpu/Android.mk Normal file
View file

@ -0,0 +1,28 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := SDL2_gpu
SDL_GPU_DIR := ./
STB_IMAGE_DIR := $(SDL_GPU_DIR)/externals/stb_image
LOCAL_CFLAGS := -I$(LOCAL_PATH)/../SDL/include -I$(LOCAL_PATH)/$(SDL_GPU_DIR) -I$(LOCAL_PATH)/$(RENDERER_DIR) -I$(LOCAL_PATH)/$(STB_IMAGE_DIR)
LOCAL_SRC_FILES := $(SDL_GPU_DIR)/SDL_gpu.c \
$(SDL_GPU_DIR)/SDL_gpu_Renderer.c \
$(SDL_GPU_DIR)/SDL_gpuShapes.c \
$(SDL_GPU_DIR)/GL_common/SDL_gpu_GL_matrix.c \
$(SDL_GPU_DIR)/GLES_1/SDL_gpu_GLES_1.c \
$(SDL_GPU_DIR)/GLES_2/SDL_gpu_GLES_2.c \
$(STB_IMAGE_DIR)/stb_image.c \
$(STB_IMAGE_DIR)/stb_image_write.c
LOCAL_CFLAGS += -DSDL_GPU_DISABLE_OPENGL -DSTBI_FAILURE_USERMSG -O3
#LOCAL_LDLIBS += -llog -lGLESv1_CM
LOCAL_LDLIBS += -llog -lGLESv2 -lGLESv1_CM
LOCAL_SHARED_LIBRARIES := SDL2
include $(BUILD_SHARED_LIBRARY)

52
src/SDL_gpu/SDL_gpu/GLES_1/SDL_gpu_GLES_1.c Normal file
View file

@ -0,0 +1,52 @@
#include "SDL_gpu_GLES_1.h"
#if defined(SDL_GPU_DISABLE_GLES) || defined(SDL_GPU_DISABLE_GLES_1)
// Dummy implementations
GPU_Renderer* GPU_CreateRenderer_GLES_1(GPU_RendererID request) {return NULL;}
void GPU_FreeRenderer_GLES_1(GPU_Renderer* renderer) {}
#else
// Most of the code pulled in from here...
#define SDL_GPU_USE_GLES
#define SDL_GPU_USE_GL_TIER2
#define SDL_GPU_GL_TIER 2
#define SDL_GPU_GLES_MAJOR_VERSION 1
#define SDL_GPU_DISABLE_SHADERS
#define SDL_GPU_APPLY_TRANSFORMS_TO_GL_STACK
#define SDL_GPU_NO_VAO
#include "../GL_common/SDL_gpu_GL_common.inl"
#include "../GL_common/SDL_gpuShapes_GL_common.inl"
GPU_Renderer* GPU_CreateRenderer_GLES_1(GPU_RendererID request)
{
GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer));
if(renderer == NULL)
return NULL;
memset(renderer, 0, sizeof(GPU_Renderer));
renderer->id = request;
renderer->id.id = GPU_RENDERER_GLES_1;
renderer->shader_language = GPU_LANGUAGE_NONE;
renderer->shader_version = 0;
renderer->current_context_target = NULL;
SET_COMMON_FUNCTIONS(renderer);
return renderer;
}
void GPU_FreeRenderer_GLES_1(GPU_Renderer* renderer)
{
if(renderer == NULL)
return;
free(renderer);
}
#endif

86
src/SDL_gpu/SDL_gpu/GLES_1/SDL_gpu_GLES_1.h Normal file
View file

@ -0,0 +1,86 @@
#ifndef _SDL_GPU_GLES_1_H__
#define _SDL_GPU_GLES_1_H__
#include "SDL_gpu.h"
#include "SDL_platform.h"
#if !defined(SDL_GPU_DISABLE_GLES) && !defined(SDL_GPU_DISABLE_GLES_1)
#ifdef __IPHONEOS__
#include <OpenGLES/ES1/gl.h>
#include <OpenGLES/ES1/glext.h>
#else
#include "GLES/gl.h"
#include "GLES/glext.h"
#endif
#define glFrustum glFrustumf
#define glOrtho glOrthof
#define glGenerateMipmap glGenerateMipmapOES
#define glDeleteFramebuffers glDeleteFramebuffersOES
#define glGenFramebuffers glGenFramebuffersOES
#define glFramebufferTexture2D glFramebufferTexture2DOES
#define glCheckFramebufferStatus glCheckFramebufferStatusOES
#define glBindFramebuffer glBindFramebufferOES
#define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
#define GL_FRAMEBUFFER_BINDING GL_FRAMEBUFFER_BINDING_OES
#define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
#define GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE_OES
#define glBlendEquation glBlendEquationOES
#define glBlendEquationSeparate glBlendEquationSeparateOES
#define glBlendFuncSeparate glBlendFuncSeparateOES
#define GL_FUNC_ADD GL_FUNC_ADD_OES
#define GL_FUNC_SUBTRACT GL_FUNC_SUBTRACT_OES
#define GL_FUNC_REVERSE_SUBTRACT GL_FUNC_REVERSE_SUBTRACT_OES
#define GL_MIRRORED_REPEAT GL_MIRRORED_REPEAT_OES
#endif
#define GPU_CONTEXT_DATA ContextData_GLES_1
#define GPU_IMAGE_DATA ImageData_GLES_1
#define GPU_TARGET_DATA TargetData_GLES_1
typedef struct ContextData_GLES_1
{
SDL_Color last_color;
Uint8 last_use_texturing;
unsigned int last_shape;
Uint8 last_use_blending;
GPU_BlendMode last_blend_mode;
GPU_Rect last_viewport;
GPU_Camera last_camera;
Uint8 last_camera_inverted;
GPU_Image* last_image;
GPU_Target* last_target;
float* blit_buffer; // Holds sets of 4 vertices and 4 tex coords interleaved (e.g. [x0, y0, z0, s0, t0, ...]).
unsigned short blit_buffer_num_vertices;
unsigned short blit_buffer_max_num_vertices;
unsigned short* index_buffer; // Indexes into the blit buffer so we can use 4 vertices for every 2 triangles (1 quad)
unsigned int index_buffer_num_vertices;
unsigned int index_buffer_max_num_vertices;
} ContextData_GLES_1;
typedef struct ImageData_GLES_1
{
int refcount;
Uint32 handle;
Uint32 format;
} ImageData_GLES_1;
typedef struct TargetData_GLES_1
{
int refcount;
Uint32 handle;
Uint32 format;
} TargetData_GLES_1;
#endif

53
src/SDL_gpu/SDL_gpu/GLES_2/SDL_gpu_GLES_2.c Normal file
View file

@ -0,0 +1,53 @@
#include "SDL_gpu_GLES_2.h"
#if defined(SDL_GPU_DISABLE_GLES) || defined(SDL_GPU_DISABLE_GLES_2)
// Dummy implementations
GPU_Renderer* GPU_CreateRenderer_GLES_2(GPU_RendererID request) {return NULL;}
void GPU_FreeRenderer_GLES_2(GPU_Renderer* renderer) {}
#else
// Most of the code pulled in from here...
#define SDL_GPU_USE_GLES
#define SDL_GPU_USE_GL_TIER3
#define SDL_GPU_GL_TIER 3
#define SDL_GPU_GLSL_VERSION 100
#define SDL_GPU_GLES_MAJOR_VERSION 2
#define SDL_GPU_NO_VAO
#include "../GL_common/SDL_gpu_GL_common.inl"
#include "../GL_common/SDL_gpuShapes_GL_common.inl"
GPU_Renderer* GPU_CreateRenderer_GLES_2(GPU_RendererID request)
{
GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer));
if(renderer == NULL)
return NULL;
memset(renderer, 0, sizeof(GPU_Renderer));
renderer->id = request;
renderer->id.id = GPU_RENDERER_GLES_2;
renderer->shader_language = GPU_LANGUAGE_GLSLES;
renderer->shader_version = SDL_GPU_GLSL_VERSION;
renderer->current_context_target = NULL;
SET_COMMON_FUNCTIONS(renderer);
return renderer;
}
void GPU_FreeRenderer_GLES_2(GPU_Renderer* renderer)
{
if(renderer == NULL)
return;
free(renderer);
}
#endif

149
src/SDL_gpu/SDL_gpu/GLES_2/SDL_gpu_GLES_2.h Normal file
View file

@ -0,0 +1,149 @@
#ifndef _SDL_GPU_GLES_2_H__
#define _SDL_GPU_GLES_2_H__
#include "SDL_gpu.h"
#include "SDL_platform.h"
#if !defined(SDL_GPU_DISABLE_GLES) && !defined(SDL_GPU_DISABLE_GLES_2)
#ifdef __IPHONEOS__
#include <OpenGLES/ES2/gl.h>
#include <OpenGLES/ES2/glext.h>
#else
#include "GLES2/gl2.h"
#include "GLES2/gl2ext.h"
#endif
#define glVertexAttribI1i glVertexAttrib1f
#define glVertexAttribI2i glVertexAttrib2f
#define glVertexAttribI3i glVertexAttrib3f
#define glVertexAttribI4i glVertexAttrib4f
#define glVertexAttribI1ui glVertexAttrib1f
#define glVertexAttribI2ui glVertexAttrib2f
#define glVertexAttribI3ui glVertexAttrib3f
#define glVertexAttribI4ui glVertexAttrib4f
#endif
#define GPU_CONTEXT_DATA ContextData_GLES_2
#define GPU_IMAGE_DATA ImageData_GLES_2
#define GPU_TARGET_DATA TargetData_GLES_2
#define GPU_DEFAULT_TEXTURED_VERTEX_SHADER_SOURCE \
"#version 100\n\
precision mediump float;\n\
precision mediump int;\n\
\
attribute vec2 gpu_Vertex;\n\
attribute vec2 gpu_TexCoord;\n\
attribute vec4 gpu_Color;\n\
uniform mat4 gpu_ModelViewProjectionMatrix;\n\
\
varying vec4 color;\n\
varying vec2 texCoord;\n\
\
void main(void)\n\
{\n\
color = gpu_Color;\n\
texCoord = vec2(gpu_TexCoord);\n\
gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
}"
// Tier 3 uses shader attributes to send position, texcoord, and color data for each vertex.
#define GPU_DEFAULT_UNTEXTURED_VERTEX_SHADER_SOURCE \
"#version 100\n\
precision mediump float;\n\
precision mediump int;\n\
\
attribute vec2 gpu_Vertex;\n\
attribute vec4 gpu_Color;\n\
uniform mat4 gpu_ModelViewProjectionMatrix;\n\
\
varying vec4 color;\n\
\
void main(void)\n\
{\n\
color = gpu_Color;\n\
gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
}"
#define GPU_DEFAULT_TEXTURED_FRAGMENT_SHADER_SOURCE \
"#version 100\n\
precision mediump float;\n\
precision mediump int;\n\
\
varying vec4 color;\n\
varying vec2 texCoord;\n\
\
uniform sampler2D tex;\n\
\
void main(void)\n\
{\n\
gl_FragColor = texture2D(tex, texCoord) * color;\n\
}"
#define GPU_DEFAULT_UNTEXTURED_FRAGMENT_SHADER_SOURCE \
"#version 100\n\
precision mediump float;\n\
precision mediump int;\n\
\
varying vec4 color;\n\
\
void main(void)\n\
{\n\
gl_FragColor = color;\n\
}"
typedef struct ContextData_GLES_2
{
SDL_Color last_color;
Uint8 last_use_texturing;
unsigned int last_shape;
Uint8 last_use_blending;
GPU_BlendMode last_blend_mode;
GPU_Rect last_viewport;
GPU_Camera last_camera;
Uint8 last_camera_inverted;
GPU_Image* last_image;
GPU_Target* last_target;
float* blit_buffer; // Holds sets of 4 vertices, each with interleaved position, tex coords, and colors (e.g. [x0, y0, z0, s0, t0, r0, g0, b0, a0, ...]).
unsigned short blit_buffer_num_vertices;
unsigned short blit_buffer_max_num_vertices;
unsigned short* index_buffer; // Indexes into the blit buffer so we can use 4 vertices for every 2 triangles (1 quad)
unsigned int index_buffer_num_vertices;
unsigned int index_buffer_max_num_vertices;
// Tier 3 rendering
unsigned int blit_VBO[2]; // For double-buffering
Uint8 blit_VBO_flop;
GPU_ShaderBlock shader_block[2];
GPU_ShaderBlock current_shader_block;
GPU_AttributeSource shader_attributes[16];
unsigned int attribute_VBO[16];
} ContextData_GLES_2;
typedef struct ImageData_GLES_2
{
int refcount;
Uint32 handle;
Uint32 format;
} ImageData_GLES_2;
typedef struct TargetData_GLES_2
{
int refcount;
Uint32 handle;
Uint32 format;
} TargetData_GLES_2;
#endif

848
src/SDL_gpu/SDL_gpu/GL_common/SDL_gpuShapes_GL_common.inl Normal file
View file

@ -0,0 +1,848 @@
/* This is an implementation file to be included after certain #defines have been set.
See a particular renderer's *.c file for specifics. */
#ifndef DEGPERRAD
#define DEGPERRAD 57.2957795f
#endif
#ifndef RADPERDEG
#define RADPERDEG 0.0174532925f
#endif
// All shapes start this way for setup and so they can access the blit buffer properly
#define BEGIN_UNTEXTURED(function_name, shape, num_additional_vertices, num_additional_indices) \
GPU_CONTEXT_DATA* cdata; \
float* blit_buffer; \
unsigned short* index_buffer; \
int vert_index; \
int color_index; \
float r, g, b, a; \
unsigned short blit_buffer_starting_index; \
if(target == NULL) \
{ \
GPU_PushErrorCode(function_name, GPU_ERROR_NULL_ARGUMENT, "target"); \
return; \
} \
if(renderer != target->renderer) \
{ \
GPU_PushErrorCode(function_name, GPU_ERROR_USER_ERROR, "Mismatched renderer"); \
return; \
} \
\
makeContextCurrent(renderer, target); \
if(renderer->current_context_target == NULL) \
{ \
GPU_PushErrorCode(function_name, GPU_ERROR_USER_ERROR, "NULL context"); \
return; \
} \
\
if(!bindFramebuffer(renderer, target)) \
{ \
GPU_PushErrorCode(function_name, GPU_ERROR_BACKEND_ERROR, "Failed to bind framebuffer."); \
return; \
} \
\
prepareToRenderToTarget(renderer, target); \
prepareToRenderShapes(renderer, shape); \
\
cdata = (GPU_CONTEXT_DATA*)renderer->current_context_target->context->data; \
\
if(cdata->blit_buffer_num_vertices + (num_additional_vertices) >= cdata->blit_buffer_max_num_vertices) \
{ \
if(!growBlitBuffer(cdata, cdata->blit_buffer_num_vertices + (num_additional_vertices))) \
renderer->FlushBlitBuffer(renderer); \
} \
if(cdata->index_buffer_num_vertices + (num_additional_indices) >= cdata->index_buffer_max_num_vertices) \
{ \
if(!growIndexBuffer(cdata, cdata->index_buffer_num_vertices + (num_additional_indices))) \
renderer->FlushBlitBuffer(renderer); \
} \
\
blit_buffer = cdata->blit_buffer; \
index_buffer = cdata->index_buffer; \
\
vert_index = GPU_BLIT_BUFFER_VERTEX_OFFSET + cdata->blit_buffer_num_vertices*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; \
color_index = GPU_BLIT_BUFFER_COLOR_OFFSET + cdata->blit_buffer_num_vertices*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; \
\
if(target->use_color) \
{ \
r = MIX_COLOR_COMPONENT_NORMALIZED_RESULT(target->color.r, color.r); \
g = MIX_COLOR_COMPONENT_NORMALIZED_RESULT(target->color.g, color.g); \
b = MIX_COLOR_COMPONENT_NORMALIZED_RESULT(target->color.b, color.b); \
a = MIX_COLOR_COMPONENT_NORMALIZED_RESULT(GET_ALPHA(target->color), GET_ALPHA(color)); \
} \
else \
{ \
r = color.r/255.0f; \
g = color.g/255.0f; \
b = color.b/255.0f; \
a = GET_ALPHA(color)/255.0f; \
} \
blit_buffer_starting_index = cdata->blit_buffer_num_vertices; \
(void)blit_buffer_starting_index;
static float SetLineThickness(GPU_Renderer* renderer, float thickness)
{
float old;
if(renderer->current_context_target == NULL)
return 1.0f;
old = renderer->current_context_target->context->line_thickness;
if(old != thickness)
renderer->FlushBlitBuffer(renderer);
renderer->current_context_target->context->line_thickness = thickness;
glLineWidth(thickness);
return old;
}
static float GetLineThickness(GPU_Renderer* renderer)
{
return renderer->current_context_target->context->line_thickness;
}
static void Pixel(GPU_Renderer* renderer, GPU_Target* target, float x, float y, SDL_Color color)
{
BEGIN_UNTEXTURED("GPU_Pixel", GL_POINTS, 1, 1);
SET_UNTEXTURED_VERTEX(x, y, r, g, b, a);
}
static void Line(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
{
float thickness = renderer->GetLineThickness(renderer);
float t = thickness/2;
float line_angle = atan2f(y2 - y1, x2 - x1);
float tc = t*cosf(line_angle);
float ts = t*sinf(line_angle);
BEGIN_UNTEXTURED("GPU_Line", GL_TRIANGLES, 4, 6);
SET_UNTEXTURED_VERTEX(x1 + ts, y1 - tc, r, g, b, a);
SET_UNTEXTURED_VERTEX(x1 - ts, y1 + tc, r, g, b, a);
SET_UNTEXTURED_VERTEX(x2 + ts, y2 - tc, r, g, b, a);
SET_INDEXED_VERTEX(1);
SET_INDEXED_VERTEX(2);
SET_UNTEXTURED_VERTEX(x2 - ts, y2 + tc, r, g, b, a);
}
// Arc() might call Circle()
static void Circle(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color);
static void Arc(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
{
float t;
float dt;
float dx, dy;
int numSegments;
if(start_angle > end_angle)
{
float swapa = end_angle;
end_angle = start_angle;
start_angle = swapa;
}
if(start_angle == end_angle)
return;
// Big angle
if(end_angle - start_angle >= 360)
{
Circle(renderer, target, x, y, radius, color);
return;
}
// Shift together
while(start_angle < 0 && end_angle < 0)
{
start_angle += 360;
end_angle += 360;
}
while(start_angle > 360 && end_angle > 360)
{
start_angle -= 360;
end_angle -= 360;
}
t = start_angle;
dt = ((end_angle - start_angle)/360)*(1.25f/sqrtf(radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
numSegments = fabs(end_angle - start_angle)/dt;
if(numSegments == 0)
return;
{
int i;
BEGIN_UNTEXTURED("GPU_Arc", GL_LINES, 1 + (numSegments - 1) + 1, 1 + (numSegments - 1) * 2 + 1);
dx = radius*cos(t*RADPERDEG);
dy = radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a); // first point
t += dt;
for (i = 1; i < numSegments; i++)
{
dx = radius*cos(t*RADPERDEG);
dy = radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a);
SET_INDEXED_VERTEX(i); // Double that vertex
t += dt;
}
// Last point
dx = radius*cos(end_angle*RADPERDEG);
dy = radius*sin(end_angle*RADPERDEG);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a);
}
}
// ArcFilled() might call CircleFilled()
static void CircleFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color);
static void ArcFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
{
float t;
float dt;
float dx, dy;
int numSegments;
if(start_angle > end_angle)
{
float swapa = end_angle;
end_angle = start_angle;
start_angle = swapa;
}
if(start_angle == end_angle)
return;
// Big angle
if(end_angle - start_angle >= 360)
{
CircleFilled(renderer, target, x, y, radius, color);
return;
}
// Shift together
while(start_angle < 0 && end_angle < 0)
{
start_angle += 360;
end_angle += 360;
}
while(start_angle > 360 && end_angle > 360)
{
start_angle -= 360;
end_angle -= 360;
}
t = start_angle;
dt = ((end_angle - start_angle)/360)*(1.25f/sqrtf(radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
numSegments = fabs(end_angle - start_angle)/dt;
if(numSegments == 0)
return;
{
int i;
BEGIN_UNTEXTURED("GPU_ArcFilled", GL_TRIANGLES, 3 + (numSegments - 1) + 1, 3 + (numSegments - 1) * 3 + 3);
// First triangle
SET_UNTEXTURED_VERTEX(x, y, r, g, b, a);
dx = radius*cos(t*RADPERDEG);
dy = radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a); // first point
t += dt;
dx = radius*cos(t*RADPERDEG);
dy = radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a); // new point
t += dt;
for (i = 2; i < numSegments + 1; i++)
{
dx = radius*cos(t*RADPERDEG);
dy = radius*sin(t*RADPERDEG);
SET_INDEXED_VERTEX(0); // center
SET_INDEXED_VERTEX(i); // last point
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a); // new point
t += dt;
}
// Last triangle
dx = radius*cos(end_angle*RADPERDEG);
dy = radius*sin(end_angle*RADPERDEG);
SET_INDEXED_VERTEX(0); // center
SET_INDEXED_VERTEX(i); // last point
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a); // new point
}
}
static void Circle(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color)
{
float t = 0;
float dt = (1.25f/sqrtf(radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
float dx, dy;
int numSegments = 360/dt+1;
int i;
BEGIN_UNTEXTURED("GPU_Circle", GL_LINES, 1 + (numSegments-1), 1 + (numSegments-1)*2 + 1);
dx = radius;
dy = 0.0f;
SET_UNTEXTURED_VERTEX(x+dx, y+dy, r, g, b, a); // first point
for(i = 1; i < numSegments; i++)
{
dx = radius*cos(t*RADPERDEG);
dy = radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x+dx, y+dy, r, g, b, a);
SET_INDEXED_VERTEX(i); // Double that vertex
t += dt;
}
SET_INDEXED_VERTEX(0); // back to the beginning
}
static void CircleFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color)
{
float t = 0;
float dt = (1.25f/sqrtf(radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
float dx, dy;
int numSegments = 360/dt+1;
int i;
BEGIN_UNTEXTURED("GPU_CircleFilled", GL_TRIANGLES, 3 + (numSegments-2), 3 + (numSegments-2)*3 + 3);
// First triangle
SET_UNTEXTURED_VERTEX(x, y, r, g, b, a);
dx = radius;
dy = 0.0f;
SET_UNTEXTURED_VERTEX(x+dx, y+dy, r, g, b, a); // first point
t += dt;
dx = radius*cos(t*RADPERDEG);
dy = radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x+dx, y+dy, r, g, b, a); // new point
t += dt;
for(i = 2; i < numSegments; i++)
{
dx = radius*cos(t*RADPERDEG);
dy = radius*sin(t*RADPERDEG);
SET_INDEXED_VERTEX(0); // center
SET_INDEXED_VERTEX(i); // last point
SET_UNTEXTURED_VERTEX(x+dx, y+dy, r, g, b, a); // new point
t += dt;
}
SET_INDEXED_VERTEX(0); // center
SET_INDEXED_VERTEX(i); // last point
SET_INDEXED_VERTEX(1); // first point
}
static void Sector(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
{
Uint8 circled;
float dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4;
if(inner_radius < 0.0f)
inner_radius = 0.0f;
if(outer_radius < 0.0f)
outer_radius = 0.0f;
if(inner_radius > outer_radius)
{
float s = inner_radius;
inner_radius = outer_radius;
outer_radius = s;
}
if(start_angle > end_angle)
{
float swapa = end_angle;
end_angle = start_angle;
start_angle = swapa;
}
if(start_angle == end_angle)
return;
if(inner_radius == outer_radius)
{
Arc(renderer, target, x, y, inner_radius, start_angle, end_angle, color);
return;
}
circled = (end_angle - start_angle >= 360);
// Composited shape... But that means error codes may be confusing. :-/
Arc(renderer, target, x, y, inner_radius, start_angle, end_angle, color);
if(!circled)
{
dx1 = inner_radius*cos(end_angle*RADPERDEG);
dy1 = inner_radius*sin(end_angle*RADPERDEG);
dx2 = outer_radius*cos(end_angle*RADPERDEG);
dy2 = outer_radius*sin(end_angle*RADPERDEG);
Line(renderer, target, x+dx1, y+dy1, x+dx2, y+dy2, color);
}
Arc(renderer, target, x, y, outer_radius, start_angle, end_angle, color);
if(!circled)
{
dx3 = inner_radius*cos(start_angle*RADPERDEG);
dy3 = inner_radius*sin(start_angle*RADPERDEG);
dx4 = outer_radius*cos(start_angle*RADPERDEG);
dy4 = outer_radius*sin(start_angle*RADPERDEG);
Line(renderer, target, x+dx3, y+dy3, x+dx4, y+dy4, color);
}
}
static void SectorFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
{
float t;
float dt;
float dx, dy;
int numSegments;
if(inner_radius < 0.0f)
inner_radius = 0.0f;
if(outer_radius < 0.0f)
outer_radius = 0.0f;
if(inner_radius > outer_radius)
{
float s = inner_radius;
inner_radius = outer_radius;
outer_radius = s;
}
if(inner_radius == outer_radius)
{
Arc(renderer, target, x, y, inner_radius, start_angle, end_angle, color);
return;
}
if(start_angle > end_angle)
{
float swapa = end_angle;
end_angle = start_angle;
start_angle = swapa;
}
if(start_angle == end_angle)
return;
if(end_angle - start_angle >= 360)
end_angle = start_angle + 360;
t = start_angle;
dt = ((end_angle - start_angle)/360)*(1.25f/sqrtf(outer_radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
numSegments = fabs(end_angle - start_angle)/dt;
if(numSegments == 0)
return;
{
int i;
Uint8 use_inner;
BEGIN_UNTEXTURED("GPU_SectorFilled", GL_TRIANGLES, 3 + (numSegments - 1) + 1, 3 + (numSegments - 1) * 3 + 3);
use_inner = 0; // Switches between the radii for the next point
// First triangle
dx = inner_radius*cos(t*RADPERDEG);
dy = inner_radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a);
dx = outer_radius*cos(t*RADPERDEG);
dy = outer_radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a);
t += dt;
dx = inner_radius*cos(t*RADPERDEG);
dy = inner_radius*sin(t*RADPERDEG);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a);
t += dt;
for (i = 2; i < numSegments + 1; i++)
{
SET_INDEXED_VERTEX(i - 1);
SET_INDEXED_VERTEX(i);
if (use_inner)
{
dx = inner_radius*cos(t*RADPERDEG);
dy = inner_radius*sin(t*RADPERDEG);
}
else
{
dx = outer_radius*cos(t*RADPERDEG);
dy = outer_radius*sin(t*RADPERDEG);
}
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a); // new point
t += dt;
use_inner = !use_inner;
}
// Last quad
t = end_angle;
if (use_inner)
{
dx = inner_radius*cos(t*RADPERDEG);
dy = inner_radius*sin(t*RADPERDEG);
}
else
{
dx = outer_radius*cos(t*RADPERDEG);
dy = outer_radius*sin(t*RADPERDEG);
}
SET_INDEXED_VERTEX(i - 1);
SET_INDEXED_VERTEX(i);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a); // new point
use_inner = !use_inner;
i++;
if (use_inner)
{
dx = inner_radius*cos(t*RADPERDEG);
dy = inner_radius*sin(t*RADPERDEG);
}
else
{
dx = outer_radius*cos(t*RADPERDEG);
dy = outer_radius*sin(t*RADPERDEG);
}
SET_INDEXED_VERTEX(i - 1);
SET_INDEXED_VERTEX(i);
SET_UNTEXTURED_VERTEX(x + dx, y + dy, r, g, b, a); // new point
}
}
static void Tri(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color)
{
BEGIN_UNTEXTURED("GPU_Tri", GL_LINES, 3, 6);
SET_UNTEXTURED_VERTEX(x1, y1, r, g, b, a);
SET_UNTEXTURED_VERTEX(x2, y2, r, g, b, a);
SET_INDEXED_VERTEX(1);
SET_UNTEXTURED_VERTEX(x3, y3, r, g, b, a);
SET_INDEXED_VERTEX(2);
SET_INDEXED_VERTEX(0);
}
static void TriFilled(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color)
{
BEGIN_UNTEXTURED("GPU_TriFilled", GL_TRIANGLES, 3, 3);
SET_UNTEXTURED_VERTEX(x1, y1, r, g, b, a);
SET_UNTEXTURED_VERTEX(x2, y2, r, g, b, a);
SET_UNTEXTURED_VERTEX(x3, y3, r, g, b, a);
}
static void Rectangle(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
{
if(y2 < y1)
{
float y = y1;
y1 = y2;
y2 = y;
}
if(x2 < x1)
{
float x = x1;
x1 = x2;
x2 = x;
}
{
float thickness = renderer->GetLineThickness(renderer);
float t = thickness / 2;
// Thick lines via filled triangles
BEGIN_UNTEXTURED("GPU_Rectangle", GL_TRIANGLES, 10, 24);
// First triangle
SET_UNTEXTURED_VERTEX(x1 - t, y1 - t, r, g, b, a);
SET_UNTEXTURED_VERTEX(x1 + t, y1 + t, r, g, b, a);
SET_UNTEXTURED_VERTEX(x2 + t, y1 - t, r, g, b, a);
SET_INDEXED_VERTEX(1);
SET_INDEXED_VERTEX(2);
SET_UNTEXTURED_VERTEX(x2 - t, y1 + t, r, g, b, a);
SET_INDEXED_VERTEX(2);
SET_INDEXED_VERTEX(3);
SET_UNTEXTURED_VERTEX(x2 + t, y2 + t, r, g, b, a);
SET_INDEXED_VERTEX(3);
SET_INDEXED_VERTEX(4);
SET_UNTEXTURED_VERTEX(x2 - t, y2 - t, r, g, b, a);
SET_INDEXED_VERTEX(4);
SET_INDEXED_VERTEX(5);
SET_UNTEXTURED_VERTEX(x1 - t, y2 + t, r, g, b, a);
SET_INDEXED_VERTEX(5);
SET_INDEXED_VERTEX(6);
SET_UNTEXTURED_VERTEX(x1 + t, y2 - t, r, g, b, a);
SET_INDEXED_VERTEX(6);
SET_INDEXED_VERTEX(7);
SET_UNTEXTURED_VERTEX(x1 - t, y1 - t, r, g, b, a);
SET_INDEXED_VERTEX(7);
SET_INDEXED_VERTEX(8);
SET_UNTEXTURED_VERTEX(x1 + t, y1 + t, r, g, b, a);
}
}
static void RectangleFilled(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
{
BEGIN_UNTEXTURED("GPU_RectangleFilled", GL_TRIANGLES, 4, 6);
SET_UNTEXTURED_VERTEX(x1, y1, r, g, b, a);
SET_UNTEXTURED_VERTEX(x1, y2, r, g, b, a);
SET_UNTEXTURED_VERTEX(x2, y1, r, g, b, a);
SET_INDEXED_VERTEX(1);
SET_INDEXED_VERTEX(2);
SET_UNTEXTURED_VERTEX(x2, y2, r, g, b, a);
}
static void RectangleRound(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float radius, SDL_Color color)
{
if(y2 < y1)
{
float temp = y2;
y2 = y1;
y1 = temp;
}
if(x2 < x1)
{
float temp = x2;
x2 = x1;
x1 = temp;
}
if(radius > (x2-x1)/2)
radius = (x2-x1)/2;
if(radius > (y2-y1)/2)
radius = (y2 - y1) / 2;
{
float tau = 2 * M_PI;
int verts_per_corner = 7;
float corner_angle_increment = (tau / 4) / (verts_per_corner - 1); // 0, 15, 30, 45, 60, 75, 90
// Starting angle
float angle = tau*0.75f;
int last_index = 1;
int i;
BEGIN_UNTEXTURED("GPU_RectangleRound", GL_LINES, 4 + 4 * (verts_per_corner - 1), 8 + 4 * (verts_per_corner - 1) * 2);
// First point
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
for (i = 1; i < verts_per_corner; i++)
{
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
SET_INDEXED_VERTEX(last_index++);
angle += corner_angle_increment;
}
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y2 - radius + sin(angle)*radius, r, g, b, a);
SET_INDEXED_VERTEX(last_index++);
for (i = 1; i < verts_per_corner; i++)
{
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y2 - radius + sin(angle)*radius, r, g, b, a);
SET_INDEXED_VERTEX(last_index++);
angle += corner_angle_increment;
}
SET_UNTEXTURED_VERTEX(x1 + radius + cos(angle)*radius, y2 - radius + sin(angle)*radius, r, g, b, a);
SET_INDEXED_VERTEX(last_index++);
for (i = 1; i < verts_per_corner; i++)
{
SET_UNTEXTURED_VERTEX(x1 + radius + cos(angle)*radius, y2 - radius + sin(angle)*radius, r, g, b, a);
SET_INDEXED_VERTEX(last_index++);
angle += corner_angle_increment;
}
SET_UNTEXTURED_VERTEX(x1 + radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
SET_INDEXED_VERTEX(last_index++);
for (i = 1; i < verts_per_corner; i++)
{
SET_UNTEXTURED_VERTEX(x1 + radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
SET_INDEXED_VERTEX(last_index++);
angle += corner_angle_increment;
}
// Last point
SET_INDEXED_VERTEX(0);
}
}
static void RectangleRoundFilled(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float radius, SDL_Color color)
{
if(y2 < y1)
{
float temp = y2;
y2 = y1;
y1 = temp;
}
if(x2 < x1)
{
float temp = x2;
x2 = x1;
x1 = temp;
}
if(radius > (x2-x1)/2)
radius = (x2-x1)/2;
if(radius > (y2-y1)/2)
radius = (y2 - y1) / 2;
{
float tau = 2 * M_PI;
int verts_per_corner = 7;
float corner_angle_increment = (tau / 4) / (verts_per_corner - 1); // 0, 15, 30, 45, 60, 75, 90
// Starting angle
float angle = tau*0.75f;
int last_index = 2;
int i;
BEGIN_UNTEXTURED("GPU_RectangleRoundFilled", GL_TRIANGLES, 6 + 4 * (verts_per_corner - 1) - 1, 15 + 4 * (verts_per_corner - 1) * 3 - 3);
// First triangle
SET_UNTEXTURED_VERTEX((x2 + x1) / 2, (y2 + y1) / 2, r, g, b, a); // Center
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
angle += corner_angle_increment;
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
angle += corner_angle_increment;
for (i = 2; i < verts_per_corner; i++)
{
SET_INDEXED_VERTEX(0);
SET_INDEXED_VERTEX(last_index++);
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
angle += corner_angle_increment;
}
SET_INDEXED_VERTEX(0);
SET_INDEXED_VERTEX(last_index++);
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y2 - radius + sin(angle)*radius, r, g, b, a);
for (i = 1; i < verts_per_corner; i++)
{
SET_INDEXED_VERTEX(0);
SET_INDEXED_VERTEX(last_index++);
SET_UNTEXTURED_VERTEX(x2 - radius + cos(angle)*radius, y2 - radius + sin(angle)*radius, r, g, b, a);
angle += corner_angle_increment;
}
SET_INDEXED_VERTEX(0);
SET_INDEXED_VERTEX(last_index++);
SET_UNTEXTURED_VERTEX(x1 + radius + cos(angle)*radius, y2 - radius + sin(angle)*radius, r, g, b, a);
for (i = 1; i < verts_per_corner; i++)
{
SET_INDEXED_VERTEX(0);
SET_INDEXED_VERTEX(last_index++);
SET_UNTEXTURED_VERTEX(x1 + radius + cos(angle)*radius, y2 - radius + sin(angle)*radius, r, g, b, a);
angle += corner_angle_increment;
}
SET_INDEXED_VERTEX(0);
SET_INDEXED_VERTEX(last_index++);
SET_UNTEXTURED_VERTEX(x1 + radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
for (i = 1; i < verts_per_corner; i++)
{
SET_INDEXED_VERTEX(0);
SET_INDEXED_VERTEX(last_index++);
SET_UNTEXTURED_VERTEX(x1 + radius + cos(angle)*radius, y1 + radius + sin(angle)*radius, r, g, b, a);
angle += corner_angle_increment;
}
// Last triangle
SET_INDEXED_VERTEX(0);
SET_INDEXED_VERTEX(last_index++);
SET_INDEXED_VERTEX(1);
}
}
static void Polygon(GPU_Renderer* renderer, GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color)
{
if(num_vertices < 3)
return;
{
int numSegments = 2 * num_vertices;
int last_index = 0;
int i;
BEGIN_UNTEXTURED("GPU_Polygon", GL_LINES, num_vertices, numSegments);
SET_UNTEXTURED_VERTEX(vertices[0], vertices[1], r, g, b, a);
for (i = 2; i < numSegments; i += 2)
{
SET_UNTEXTURED_VERTEX(vertices[i], vertices[i + 1], r, g, b, a);
last_index++;
SET_INDEXED_VERTEX(last_index); // Double the last one for the next line
}
SET_INDEXED_VERTEX(0);
}
}
static void PolygonFilled(GPU_Renderer* renderer, GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color)
{
if(num_vertices < 3)
return;
{
int numSegments = 2 * num_vertices;
// Using a fan of triangles assumes that the polygon is convex
BEGIN_UNTEXTURED("GPU_PolygonFilled", GL_TRIANGLES, num_vertices, 3 + (num_vertices - 3) * 3);
// First triangle
SET_UNTEXTURED_VERTEX(vertices[0], vertices[1], r, g, b, a);
SET_UNTEXTURED_VERTEX(vertices[2], vertices[3], r, g, b, a);
SET_UNTEXTURED_VERTEX(vertices[4], vertices[5], r, g, b, a);
if (num_vertices > 3)
{
int last_index = 2;
int i;
for (i = 6; i < numSegments; i += 2)
{
SET_INDEXED_VERTEX(0); // Start from the first vertex
SET_INDEXED_VERTEX(last_index); // Double the last one
SET_UNTEXTURED_VERTEX(vertices[i], vertices[i + 1], r, g, b, a);
last_index++;
}
}
}
}

5655
src/SDL_gpu/SDL_gpu/GL_common/SDL_gpu_GL_common.inl Normal file
View file

File diff suppressed because it is too large Load diff

353
src/SDL_gpu/SDL_gpu/GL_common/SDL_gpu_GL_matrix.c Normal file
View file

@ -0,0 +1,353 @@
#include "SDL_gpu.h"
#include "SDL_gpu_GL_matrix.h"
#include <math.h>
#include <string.h>
#ifdef _MSC_VER
#define __func__ __FUNCTION__
#endif
#ifndef M_PI
#define M_PI 3.1415926f
#endif
// Visual C does not support static inline
#ifndef static_inline
#ifdef _MSC_VER
#define static_inline static
#else
#define static_inline static inline
#endif
#endif
// Visual C does not support C99 (which includes a safe snprintf)
#ifdef _MSC_VER
#define snprintf c99_snprintf
// From Valentin Milea: http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
static_inline int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap)
{
int count = -1;
if (size != 0)
count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
if (count == -1)
count = _vscprintf(format, ap);
return count;
}
static_inline int c99_snprintf(char* str, size_t size, const char* format, ...)
{
int count;
va_list ap;
va_start(ap, format);
count = c99_vsnprintf(str, size, format, ap);
va_end(ap);
return count;
}
#endif
// Implementations based on Wayne Cochran's (wcochran) matrix.c
// Column-major
#define INDEX(row,col) ((col)*4 + (row))
void GPU_MatrixCopy(float* result, const float* A)
{
memcpy(result, A, 16*sizeof(float));
}
void GPU_MatrixIdentity(float* result)
{
memset(result, 0, 16*sizeof(float));
result[0] = result[5] = result[10] = result[15] = 1;
}
// Matrix multiply: result = A * B
void GPU_Multiply4x4(float* result, float* A, float* B)
{
int r, c, i;
float s;
for(r = 0; r < 4; r++)
{
for(c = 0; c < 4; c++)
{
s = 0;
for(i = 0; i < 4; i++)
s += A[INDEX(r,i)]*B[INDEX(i,c)];
result[INDEX(r,c)] = s;
}
}
}
void GPU_MultiplyAndAssign(float* result, float* A)
{
float temp[16];
GPU_Multiply4x4(temp, result, A);
GPU_MatrixCopy(result, temp);
}
// Can be used up to two times per line evaluation...
const char* GPU_GetMatrixString(float* A)
{
static char buffer[512];
static char buffer2[512];
static char flip = 0;
char* b = (flip? buffer : buffer2);
flip = !flip;
snprintf(b, 512, "%.1f %.1f %.1f %.1f\n"
"%.1f %.1f %.1f %.1f\n"
"%.1f %.1f %.1f %.1f\n"
"%.1f %.1f %.1f %.1f",
A[0], A[1], A[2], A[3],
A[4], A[5], A[6], A[7],
A[8], A[9], A[10], A[11],
A[12], A[13], A[14], A[15]);
return b;
}
void GPU_MatrixMode(int matrix_mode)
{
GPU_Target* target = GPU_GetContextTarget();
if(target == NULL || target->context == NULL)
return;
target->context->matrix_mode = matrix_mode;
}
float* GPU_GetModelView(void)
{
GPU_Target* target = GPU_GetContextTarget();
GPU_MatrixStack* stack;
if(target == NULL || target->context == NULL)
return NULL;
stack = &target->context->modelview_matrix;
if(stack->size == 0)
return NULL;
return stack->matrix[stack->size-1];
}
float* GPU_GetProjection(void)
{
GPU_Target* target = GPU_GetContextTarget();
GPU_MatrixStack* stack;
if(target == NULL || target->context == NULL)
return NULL;
stack = &target->context->projection_matrix;
if(stack->size == 0)
return NULL;
return stack->matrix[stack->size-1];
}
float* GPU_GetCurrentMatrix(void)
{
GPU_Target* target = GPU_GetContextTarget();
GPU_MatrixStack* stack;
if(target == NULL || target->context == NULL)
return NULL;
if(target->context->matrix_mode == GPU_MODELVIEW)
stack = &target->context->modelview_matrix;
else
stack = &target->context->projection_matrix;
if(stack->size == 0)
return NULL;
return stack->matrix[stack->size-1];
}
void GPU_PushMatrix()
{
GPU_Target* target = GPU_GetContextTarget();
GPU_MatrixStack* stack;
if(target == NULL || target->context == NULL)
return;
stack = (target->context->matrix_mode == GPU_MODELVIEW? &target->context->modelview_matrix : &target->context->projection_matrix);
if(stack->size + 1 >= GPU_MATRIX_STACK_MAX)
{
GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "Matrix stack is full (%d)", GPU_MATRIX_STACK_MAX);
return;
}
GPU_MatrixCopy(stack->matrix[stack->size], stack->matrix[stack->size-1]);
stack->size++;
}
void GPU_PopMatrix()
{
GPU_Target* target = GPU_GetContextTarget();
GPU_MatrixStack* stack;
if(target == NULL || target->context == NULL)
return;
stack = (target->context->matrix_mode == GPU_MODELVIEW? &target->context->modelview_matrix : &target->context->projection_matrix);
if(stack->size == 0)
{
GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "Matrix stack is empty.");
return;
}
stack->size--;
}
void GPU_LoadIdentity(void)
{
float* result = GPU_GetCurrentMatrix();
if(result == NULL)
return;
GPU_MatrixIdentity(result);
}
void GPU_Ortho(float left, float right, float bottom, float top, float near, float far)
{
float* result = GPU_GetCurrentMatrix();
if(result == NULL)
return;
{
#ifdef ROW_MAJOR
float A[16] = {2/(right - left), 0, 0, -(right + left)/(right - left),
0, 2/(top - bottom), 0, -(top + bottom)/(top - bottom),
0, 0, -2/(far - near), -(far + near)/(far - near),
0, 0, 0, 1};
#else
float A[16] = { 2 / (right - left), 0, 0, 0,
0, 2 / (top - bottom), 0, 0,
0, 0, -2 / (far - near), 0,
-(right + left) / (right - left), -(top + bottom) / (top - bottom), -(far + near) / (far - near), 1 };
#endif
GPU_MultiplyAndAssign(result, A);
}
}
void GPU_Frustum(float right, float left, float bottom, float top, float near, float far)
{
float* result = GPU_GetCurrentMatrix();
if(result == NULL)
return;
{
#ifdef ROW_MAJOR
float A[16] = {2 * near / (right - left), 0, 0, 0,
0, 2 * near / (top - bottom), 0, 0,
(right + left) / (right - left), (top + bottom) / (top - bottom), -(far + near) / (far - near), -1,
0, 0, -(2 * far * near) / (far - near), 0};
#else
float A[16] = { 2 * near / (right - left), 0, (right + left) / (right - left), 0,
0, 2 * near / (top - bottom), (top + bottom) / (top - bottom), 0,
0, 0, -(far + near) / (far - near), -(2 * far * near) / (far - near),
0, 0, -1, 0 };
#endif
GPU_MultiplyAndAssign(result, A);
}
}
void GPU_Translate(float x, float y, float z)
{
float* result = GPU_GetCurrentMatrix();
if(result == NULL)
return;
{
#ifdef ROW_MAJOR
float A[16] = {1, 0, 0, x,
0, 1, 0, y,
0, 0, 1, z,
0, 0, 0, 1};
#else
float A[16] = { 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
x, y, z, 1 };
#endif
GPU_MultiplyAndAssign(result, A);
}
}
void GPU_Scale(float sx, float sy, float sz)
{
float* result = GPU_GetCurrentMatrix();
if(result == NULL)
return;
{
float A[16] = { sx, 0, 0, 0,
0, sy, 0, 0,
0, 0, sz, 0,
0, 0, 0, 1 };
GPU_MultiplyAndAssign(result, A);
}
}
void GPU_Rotate(float degrees, float x, float y, float z)
{
float p, radians, c, s, c_, zc_, yc_, xzc_, xyc_, yzc_, xs, ys, zs;
float* result;
p = 1/sqrtf(x*x + y*y + z*z);
x *= p; y *= p; z *= p;
radians = degrees * (M_PI/180);
c = cosf(radians);
s = sinf(radians);
c_ = 1 - c;
zc_ = z*c_;
yc_ = y*c_;
xzc_ = x*zc_;
xyc_ = x*y*c_;
yzc_ = y*zc_;
xs = x*s;
ys = y*s;
zs = z*s;
result = GPU_GetCurrentMatrix();
if(result == NULL)
return;
{
#ifdef ROW_MAJOR
float A[16] = {x*x*c_ + c, xyc_ - zs, xzc_ + ys, 0,
xyc_ + zs, y*yc_ + c, yzc_ - xs, 0,
xzc_ - ys, yzc_ + xs, z*zc_ + c, 0,
0, 0, 0, 1};
#else
float A[16] = { x*x*c_ + c, xyc_ + zs, xzc_ - ys, 0,
xyc_ - zs, y*yc_ + c, yzc_ + xs, 0,
xzc_ + ys, yzc_ - xs, z*zc_ + c, 0,
0, 0, 0, 1 };
#endif
GPU_MultiplyAndAssign(result, A);
}
}
void GPU_MultMatrix(float* A)
{
float* result = GPU_GetCurrentMatrix();
if(result == NULL)
return;
GPU_MultiplyAndAssign(result, A);
}
void GPU_GetModelViewProjection(float* result)
{
// MVP = P * MV
GPU_Multiply4x4(result, GPU_GetProjection(), GPU_GetModelView());
}

39
src/SDL_gpu/SDL_gpu/GL_common/SDL_gpu_GL_matrix.h Normal file
View file

@ -0,0 +1,39 @@
#ifndef _SDL_GPU_GL_MATRIX_H__
#define _SDL_GPU_GL_MATRIX_H__
#ifdef __cplusplus
extern "C" {
#endif
// Basic matrix operations
void GPU_MatrixCopy(float* result, const float* A);
void GPU_MatrixIdentity(float* result);
void GPU_Multiply4x4(float* result, float* A, float* B);
void GPU_MultiplyAndAssign(float* result, float* A);
// State-specific operations
#define GPU_MODELVIEW 0
#define GPU_PROJECTION 1
const char* GPU_GetMatrixString(float* A);
void GPU_MatrixMode(int matrix_mode);
float* GPU_GetCurrentMatrix(void);
float* GPU_GetModelView(void);
float* GPU_GetProjection(void);
void GPU_GetModelViewProjection(float* result);
void GPU_PushMatrix(void);
void GPU_PopMatrix(void);
void GPU_LoadIdentity(void);
void GPU_Ortho(float left, float right, float bottom, float top, float near, float far);
void GPU_Frustum(float right, float left, float bottom, float top, float near, float far);
void GPU_Translate(float x, float y, float z);
void GPU_Scale(float sx, float sy, float sz);
void GPU_Rotate(float degrees, float x, float y, float z);
void GPU_MultMatrix(float* matrix4x4);
#ifdef __cplusplus
}
#endif
#endif

51
src/SDL_gpu/SDL_gpu/OpenGL_1/SDL_gpu_OpenGL_1.c Normal file
View file

@ -0,0 +1,51 @@
#include "SDL_gpu_OpenGL_1.h"
#if defined(SDL_GPU_DISABLE_OPENGL) || defined(SDL_GPU_DISABLE_OPENGL_1)
// Dummy implementations
GPU_Renderer* GPU_CreateRenderer_OpenGL_1(GPU_RendererID request) {return NULL;}
void GPU_FreeRenderer_OpenGL_1(GPU_Renderer* renderer) {}
#else
// Most of the code pulled in from here...
#define SDL_GPU_USE_OPENGL
#define SDL_GPU_USE_GL_TIER3
#define SDL_GPU_GL_TIER 3
#define SDL_GPU_GLSL_VERSION 110
#define SDL_GPU_GL_MAJOR_VERSION 1
#define SDL_GPU_NO_VAO
#include "../GL_common/SDL_gpu_GL_common.inl"
#include "../GL_common/SDL_gpuShapes_GL_common.inl"
GPU_Renderer* GPU_CreateRenderer_OpenGL_1(GPU_RendererID request)
{
GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer));
if(renderer == NULL)
return NULL;
memset(renderer, 0, sizeof(GPU_Renderer));
renderer->id = request;
renderer->id.id = GPU_RENDERER_OPENGL_1;
renderer->shader_language = GPU_LANGUAGE_GLSL;
renderer->shader_version = SDL_GPU_GLSL_VERSION;
renderer->current_context_target = NULL;
SET_COMMON_FUNCTIONS(renderer);
return renderer;
}
void GPU_FreeRenderer_OpenGL_1(GPU_Renderer* renderer)
{
if(renderer == NULL)
return;
free(renderer);
}
#endif

270
src/SDL_gpu/SDL_gpu/OpenGL_1/SDL_gpu_OpenGL_1.h Normal file
View file

@ -0,0 +1,270 @@
#ifndef _SDL_GPU_OPENGL_1_H__
#define _SDL_GPU_OPENGL_1_H__
#include "SDL_gpu.h"
#if !defined(SDL_GPU_DISABLE_OPENGL) && !defined(SDL_GPU_DISABLE_OPENGL_1)
// Hacks to fix compile errors due to polluted namespace
#ifdef _WIN32
#define _WINUSER_H
#define _WINGDI_H
#endif
#include "glew.h"
#if defined(GL_EXT_bgr) && !defined(GL_BGR)
#define GL_BGR GL_BGR_EXT
#endif
#if defined(GL_EXT_bgra) && !defined(GL_BGRA)
#define GL_BGRA GL_BGRA_EXT
#endif
#if defined(GL_EXT_abgr) && !defined(GL_ABGR)
#define GL_ABGR GL_ABGR_EXT
#endif
#undef glBlendFuncSeparate
#define glBlendFuncSeparate glBlendFuncSeparateEXT
#undef glBlendEquation
#define glBlendEquation glBlendEquationEXT
#undef glBlendEquationSeparate
#define glBlendEquationSeparate glBlendEquationSeparateEXT
#undef GL_MIRRORED_REPEAT
#define GL_MIRRORED_REPEAT GL_MIRRORED_REPEAT_ARB
#undef glCreateShader
#undef GL_VERTEX_SHADER
#undef GL_FRAGMENT_SHADER
#undef glShaderSource
#undef glCompileShader
#undef glGetShaderiv
#undef GL_COMPILE_STATUS
#undef glGetShaderInfoLog
#undef glDeleteShader
#undef glActiveTexture
#undef GL_TEXTURE0
#define glCreateShader glCreateShaderObjectARB
#define GL_VERTEX_SHADER GL_VERTEX_SHADER_ARB
#define GL_FRAGMENT_SHADER GL_FRAGMENT_SHADER_ARB
#define glShaderSource glShaderSourceARB
#define glCompileShader glCompileShaderARB
#define glGetShaderiv glGetObjectParameterivARB
#define GL_COMPILE_STATUS GL_OBJECT_COMPILE_STATUS_ARB
#define glGetShaderInfoLog glGetInfoLogARB
#define glDeleteShader glDeleteObjectARB
#define glActiveTexture glActiveTextureARB
#define GL_TEXTURE0 GL_TEXTURE0_ARB
#undef glCreateProgram
#undef glAttachShader
#undef glLinkProgram
#undef GL_LINK_STATUS
#undef glGetProgramiv
#undef glGetProgramInfoLog
#undef glUseProgram
#undef glDeleteProgram
#define glCreateProgram glCreateProgramObjectARB
#define glAttachShader glAttachObjectARB
#define glLinkProgram glLinkProgramARB
#define GL_LINK_STATUS GL_OBJECT_LINK_STATUS_ARB
#define glGetProgramiv glGetObjectParameterivARB
#define glGetProgramInfoLog glGetInfoLogARB
#define glUseProgram glUseProgramObjectARB
#define glDeleteProgram glDeleteObjectARB
#undef glGetUniformLocation
#undef glGetUniformiv
#undef glUniform1i
#undef glUniform1iv
#undef glUniform2iv
#undef glUniform3iv
#undef glUniform4iv
#undef glUniform1f
#undef glUniform1fv
#undef glUniform2fv
#undef glUniform3fv
#undef glUniform4fv
#undef glUniformMatrix4fv
#define glGetUniformLocation glGetUniformLocationARB
#define glGetUniformiv glGetUniformivARB
#define glUniform1i glUniform1iARB
#define glUniform1iv glUniform1ivARB
#define glUniform2iv glUniform2ivARB
#define glUniform3iv glUniform3ivARB
#define glUniform4iv glUniform4ivARB
#define glUniform1f glUniform1fARB
#define glUniform1fv glUniform1fvARB
#define glUniform2fv glUniform2fvARB
#define glUniform3fv glUniform3fvARB
#define glUniform4fv glUniform4fvARB
#define glUniformMatrix4fv glUniformMatrix4fvARB
#undef glGetAttribLocation
#undef glVertexAttrib1f
#undef glVertexAttrib2f
#undef glVertexAttrib3f
#undef glVertexAttrib4f
#undef glVertexAttribI1i
#undef glVertexAttribI2i
#undef glVertexAttribI3i
#undef glVertexAttribI4i
#undef glVertexAttribI1ui
#undef glVertexAttribI2ui
#undef glVertexAttribI3ui
#undef glVertexAttribI4ui
#define glGetAttribLocation glGetAttribLocationARB
#define glVertexAttrib1f glVertexAttrib1fARB
#define glVertexAttrib2f glVertexAttrib2fARB
#define glVertexAttrib3f glVertexAttrib3fARB
#define glVertexAttrib4f glVertexAttrib4fARB
#define glVertexAttribI1i glVertexAttrib1sARB
#define glVertexAttribI2i glVertexAttrib2sARB
#define glVertexAttribI3i glVertexAttrib3sARB
#define glVertexAttribI4i glVertexAttrib4sARB
#define glVertexAttribI1ui glVertexAttrib1sARB
#define glVertexAttribI2ui glVertexAttrib2sARB
#define glVertexAttribI3ui glVertexAttrib3sARB
#define glVertexAttribI4ui glVertexAttrib4sARB
#undef glGenBuffers
#undef glDeleteBuffers
#undef glBindBuffer
#undef glBufferData
#undef glBufferSubData
#undef GL_ARRAY_BUFFER
#define glGenBuffers glGenBuffersARB
#define glDeleteBuffers glDeleteBuffersARB
#define glBindBuffer glBindBufferARB
#define glBufferData glBufferDataARB
#define glBufferSubData glBufferSubDataARB
#define GL_ARRAY_BUFFER GL_ARRAY_BUFFER_ARB
#undef glEnableVertexAttribArray
#undef glDisableVertexAttribArray
#undef glVertexAttribPointer
#define glEnableVertexAttribArray glEnableVertexAttribArrayARB
#define glDisableVertexAttribArray glDisableVertexAttribArrayARB
#define glVertexAttribPointer glVertexAttribPointerARB
#endif
#define GPU_CONTEXT_DATA ContextData_OpenGL_1
#define GPU_IMAGE_DATA ImageData_OpenGL_1
#define GPU_TARGET_DATA TargetData_OpenGL_1
#define GPU_DEFAULT_TEXTURED_VERTEX_SHADER_SOURCE \
"#version 110\n\
\
attribute vec2 gpu_Vertex;\n\
attribute vec2 gpu_TexCoord;\n\
attribute vec4 gpu_Color;\n\
uniform mat4 gpu_ModelViewProjectionMatrix;\n\
\
varying vec4 color;\n\
varying vec2 texCoord;\n\
\
void main(void)\n\
{\n\
color = gpu_Color;\n\
texCoord = vec2(gpu_TexCoord);\n\
gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
}"
// Tier 3 uses shader attributes to send position, texcoord, and color data for each vertex.
#define GPU_DEFAULT_UNTEXTURED_VERTEX_SHADER_SOURCE \
"#version 110\n\
\
attribute vec2 gpu_Vertex;\n\
attribute vec4 gpu_Color;\n\
uniform mat4 gpu_ModelViewProjectionMatrix;\n\
\
varying vec4 color;\n\
\
void main(void)\n\
{\n\
color = gpu_Color;\n\
gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
}"
#define GPU_DEFAULT_TEXTURED_FRAGMENT_SHADER_SOURCE \
"#version 110\n\
\
varying vec4 color;\n\
varying vec2 texCoord;\n\
\
uniform sampler2D tex;\n\
\
void main(void)\n\
{\n\
gl_FragColor = texture2D(tex, texCoord) * color;\n\
}"
#define GPU_DEFAULT_UNTEXTURED_FRAGMENT_SHADER_SOURCE \
"#version 110\n\
\
varying vec4 color;\n\
\
void main(void)\n\
{\n\
gl_FragColor = color;\n\
}"
typedef struct ContextData_OpenGL_1
{
SDL_Color last_color;
Uint8 last_use_texturing;
unsigned int last_shape;
Uint8 last_use_blending;
GPU_BlendMode last_blend_mode;
GPU_Rect last_viewport;
GPU_Camera last_camera;
Uint8 last_camera_inverted;
GPU_Image* last_image;
GPU_Target* last_target;
float* blit_buffer; // Holds sets of 4 vertices and 4 tex coords interleaved (e.g. [x0, y0, z0, s0, t0, ...]).
unsigned short blit_buffer_num_vertices;
unsigned short blit_buffer_max_num_vertices;
unsigned short* index_buffer; // Indexes into the blit buffer so we can use 4 vertices for every 2 triangles (1 quad)
unsigned int index_buffer_num_vertices;
unsigned int index_buffer_max_num_vertices;
unsigned int blit_VBO[2]; // For double-buffering
Uint8 blit_VBO_flop;
GPU_ShaderBlock shader_block[2];
GPU_ShaderBlock current_shader_block;
GPU_AttributeSource shader_attributes[16];
unsigned int attribute_VBO[16];
} ContextData_OpenGL_1;
typedef struct ImageData_OpenGL_1
{
int refcount;
Uint32 handle;
Uint32 format;
} ImageData_OpenGL_1;
typedef struct TargetData_OpenGL_1
{
int refcount;
Uint32 handle;
Uint32 format;
} TargetData_OpenGL_1;
#endif

52
src/SDL_gpu/SDL_gpu/OpenGL_1_BASE/SDL_gpu_OpenGL_1_BASE.c Normal file
View file

@ -0,0 +1,52 @@
#include "SDL_gpu_OpenGL_1_BASE.h"
#if defined(SDL_GPU_DISABLE_OPENGL) || defined(SDL_GPU_DISABLE_OPENGL_1_BASE)
// Dummy implementations
GPU_Renderer* GPU_CreateRenderer_OpenGL_1_BASE(GPU_RendererID request) {return NULL;}
void GPU_FreeRenderer_OpenGL_1_BASE(GPU_Renderer* renderer) {}
#else
// Most of the code pulled in from here...
#define SDL_GPU_USE_OPENGL
#define SDL_GPU_DISABLE_SHADERS
#define SDL_GPU_USE_GL_TIER1
#define SDL_GPU_GL_TIER 1
#define SDL_GPU_GL_MAJOR_VERSION 1
#define SDL_GPU_APPLY_TRANSFORMS_TO_GL_STACK
#define SDL_GPU_NO_VAO
#include "../GL_common/SDL_gpu_GL_common.inl"
#include "../GL_common/SDL_gpuShapes_GL_common.inl"
GPU_Renderer* GPU_CreateRenderer_OpenGL_1_BASE(GPU_RendererID request)
{
GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer));
if(renderer == NULL)
return NULL;
memset(renderer, 0, sizeof(GPU_Renderer));
renderer->id = request;
renderer->id.id = GPU_RENDERER_OPENGL_1_BASE;
renderer->shader_language = GPU_LANGUAGE_NONE;
renderer->shader_version = 0;
renderer->current_context_target = NULL;
SET_COMMON_FUNCTIONS(renderer);
return renderer;
}
void GPU_FreeRenderer_OpenGL_1_BASE(GPU_Renderer* renderer)
{
if(renderer == NULL)
return;
free(renderer);
}
#endif

76
src/SDL_gpu/SDL_gpu/OpenGL_1_BASE/SDL_gpu_OpenGL_1_BASE.h Normal file
View file

@ -0,0 +1,76 @@
#ifndef _SDL_GPU_OPENGL_1_BASE_H__
#define _SDL_GPU_OPENGL_1_BASE_H__
#include "SDL_gpu.h"
#if !defined(SDL_GPU_DISABLE_OPENGL) && !defined(SDL_GPU_DISABLE_OPENGL_1_BASE)
// Hacks to fix compile errors due to polluted namespace
#ifdef _WIN32
#define _WINUSER_H
#define _WINGDI_H
#endif
#include "glew.h"
#if defined(GL_EXT_bgr) && !defined(GL_BGR)
#define GL_BGR GL_BGR_EXT
#endif
#if defined(GL_EXT_bgra) && !defined(GL_BGRA)
#define GL_BGRA GL_BGRA_EXT
#endif
#if defined(GL_EXT_abgr) && !defined(GL_ABGR)
#define GL_ABGR GL_ABGR_EXT
#endif
#undef GL_MIRRORED_REPEAT
#define GL_MIRRORED_REPEAT GL_MIRRORED_REPEAT_ARB
#endif
#define GPU_CONTEXT_DATA ContextData_OpenGL_1_BASE
#define GPU_IMAGE_DATA ImageData_OpenGL_1_BASE
#define GPU_TARGET_DATA TargetData_OpenGL_1_BASE
typedef struct ContextData_OpenGL_1_BASE
{
SDL_Color last_color;
Uint8 last_use_texturing;
unsigned int last_shape;
Uint8 last_use_blending;
GPU_BlendMode last_blend_mode;
GPU_Rect last_viewport;
GPU_Camera last_camera;
Uint8 last_camera_inverted;
GPU_Image* last_image;
GPU_Target* last_target;
float* blit_buffer; // Holds sets of 4 vertices and 4 tex coords interleaved (e.g. [x0, y0, z0, s0, t0, ...]).
unsigned short blit_buffer_num_vertices;
unsigned short blit_buffer_max_num_vertices;
unsigned short* index_buffer; // Indexes into the blit buffer so we can use 4 vertices for every 2 triangles (1 quad)
unsigned int index_buffer_num_vertices;
unsigned int index_buffer_max_num_vertices;
} ContextData_OpenGL_1_BASE;
typedef struct ImageData_OpenGL_1_BASE
{
int refcount;
Uint32 handle;
Uint32 format;
} ImageData_OpenGL_1_BASE;
typedef struct TargetData_OpenGL_1_BASE
{
int refcount;
Uint32 handle;
Uint32 format;
} TargetData_OpenGL_1_BASE;
#endif

52
src/SDL_gpu/SDL_gpu/OpenGL_2/SDL_gpu_OpenGL_2.c Normal file
View file

@ -0,0 +1,52 @@
#include "SDL_gpu_OpenGL_2.h"
#if defined(SDL_GPU_DISABLE_OPENGL) || defined(SDL_GPU_DISABLE_OPENGL_2)
// Dummy implementations
GPU_Renderer* GPU_CreateRenderer_OpenGL_2(GPU_RendererID request) {return NULL;}
void GPU_FreeRenderer_OpenGL_2(GPU_Renderer* renderer) {}
#else
// Most of the code pulled in from here...
#define SDL_GPU_USE_OPENGL
#define SDL_GPU_USE_GL_TIER3
#define SDL_GPU_GL_TIER 3
#define SDL_GPU_GLSL_VERSION 120
#define SDL_GPU_GL_MAJOR_VERSION 2
#define SDL_GPU_NO_VAO
#include "../GL_common/SDL_gpu_GL_common.inl"
#include "../GL_common/SDL_gpuShapes_GL_common.inl"
GPU_Renderer* GPU_CreateRenderer_OpenGL_2(GPU_RendererID request)
{
GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer));
if(renderer == NULL)
return NULL;
memset(renderer, 0, sizeof(GPU_Renderer));
renderer->id = request;
renderer->id.id = GPU_RENDERER_OPENGL_2;
renderer->shader_language = GPU_LANGUAGE_GLSL;
renderer->shader_version = SDL_GPU_GLSL_VERSION;
renderer->current_context_target = NULL;
SET_COMMON_FUNCTIONS(renderer);
return renderer;
}
void GPU_FreeRenderer_OpenGL_2(GPU_Renderer* renderer)
{
if(renderer == NULL)
return;
free(renderer);
}
#endif

141
src/SDL_gpu/SDL_gpu/OpenGL_2/SDL_gpu_OpenGL_2.h Normal file
View file

@ -0,0 +1,141 @@
#ifndef _SDL_GPU_OPENGL_2_H__
#define _SDL_GPU_OPENGL_2_H__
#include "SDL_gpu.h"
#if !defined(SDL_GPU_DISABLE_OPENGL) && !defined(SDL_GPU_DISABLE_OPENGL_2)
// Hacks to fix compile errors due to polluted namespace
#ifdef _WIN32
#define _WINUSER_H
#define _WINGDI_H
#endif
#include "glew.h"
#if defined(GL_EXT_bgr) && !defined(GL_BGR)
#define GL_BGR GL_BGR_EXT
#endif
#if defined(GL_EXT_bgra) && !defined(GL_BGRA)
#define GL_BGRA GL_BGRA_EXT
#endif
#if defined(GL_EXT_abgr) && !defined(GL_ABGR)
#define GL_ABGR GL_ABGR_EXT
#endif
#endif
#define GPU_CONTEXT_DATA ContextData_OpenGL_2
#define GPU_IMAGE_DATA ImageData_OpenGL_2
#define GPU_TARGET_DATA TargetData_OpenGL_2
#define GPU_DEFAULT_TEXTURED_VERTEX_SHADER_SOURCE \
"#version 120\n\
\
attribute vec2 gpu_Vertex;\n\
attribute vec2 gpu_TexCoord;\n\
attribute vec4 gpu_Color;\n\
uniform mat4 gpu_ModelViewProjectionMatrix;\n\
\
varying vec4 color;\n\
varying vec2 texCoord;\n\
\
void main(void)\n\
{\n\
color = gpu_Color;\n\
texCoord = vec2(gpu_TexCoord);\n\
gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
}"
// Tier 3 uses shader attributes to send position, texcoord, and color data for each vertex.
#define GPU_DEFAULT_UNTEXTURED_VERTEX_SHADER_SOURCE \
"#version 120\n\
\
attribute vec2 gpu_Vertex;\n\
attribute vec4 gpu_Color;\n\
uniform mat4 gpu_ModelViewProjectionMatrix;\n\
\
varying vec4 color;\n\
\
void main(void)\n\
{\n\
color = gpu_Color;\n\
gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
}"
#define GPU_DEFAULT_TEXTURED_FRAGMENT_SHADER_SOURCE \
"#version 120\n\
\
varying vec4 color;\n\
varying vec2 texCoord;\n\
\
uniform sampler2D tex;\n\
\
void main(void)\n\
{\n\
gl_FragColor = texture2D(tex, texCoord) * color;\n\
}"
#define GPU_DEFAULT_UNTEXTURED_FRAGMENT_SHADER_SOURCE \
"#version 120\n\
\
varying vec4 color;\n\
\
void main(void)\n\
{\n\
gl_FragColor = color;\n\
}"
typedef struct ContextData_OpenGL_2
{
SDL_Color last_color;
Uint8 last_use_texturing;
unsigned int last_shape;
Uint8 last_use_blending;
GPU_BlendMode last_blend_mode;
GPU_Rect last_viewport;
GPU_Camera last_camera;
Uint8 last_camera_inverted;
GPU_Image* last_image;
GPU_Target* last_target;
float* blit_buffer; // Holds sets of 4 vertices and 4 tex coords interleaved (e.g. [x0, y0, z0, s0, t0, ...]).
unsigned short blit_buffer_num_vertices;
unsigned short blit_buffer_max_num_vertices;
unsigned short* index_buffer; // Indexes into the blit buffer so we can use 4 vertices for every 2 triangles (1 quad)
unsigned int index_buffer_num_vertices;
unsigned int index_buffer_max_num_vertices;
unsigned int blit_VBO[2]; // For double-buffering
Uint8 blit_VBO_flop;
GPU_ShaderBlock shader_block[2];
GPU_ShaderBlock current_shader_block;
GPU_AttributeSource shader_attributes[16];
unsigned int attribute_VBO[16];
} ContextData_OpenGL_2;
typedef struct ImageData_OpenGL_2
{
int refcount;
Uint32 handle;
Uint32 format;
} ImageData_OpenGL_2;
typedef struct TargetData_OpenGL_2
{
int refcount;
Uint32 handle;
Uint32 format;
} TargetData_OpenGL_2;
#endif

52
src/SDL_gpu/SDL_gpu/OpenGL_3/SDL_gpu_OpenGL_3.c Normal file
View file

@ -0,0 +1,52 @@
#include "SDL_gpu_OpenGL_3.h"
#if defined(SDL_GPU_DISABLE_OPENGL) || defined(SDL_GPU_DISABLE_OPENGL_3)
// Dummy implementations
GPU_Renderer* GPU_CreateRenderer_OpenGL_3(GPU_RendererID request) {return NULL;}
void GPU_FreeRenderer_OpenGL_3(GPU_Renderer* renderer) {}
#else
// Most of the code pulled in from here...
#define SDL_GPU_USE_OPENGL
#define SDL_GPU_USE_GL_TIER3
#define SDL_GPU_GL_TIER 3
#define SDL_GPU_GLSL_VERSION 130
#define SDL_GPU_GL_MAJOR_VERSION 3
#include "../GL_common/SDL_gpu_GL_common.inl"
#include "../GL_common/SDL_gpuShapes_GL_common.inl"
GPU_Renderer* GPU_CreateRenderer_OpenGL_3(GPU_RendererID request)
{
GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer));
if(renderer == NULL)
return NULL;
memset(renderer, 0, sizeof(GPU_Renderer));
renderer->id = request;
renderer->id.id = GPU_RENDERER_OPENGL_3;
renderer->shader_language = GPU_LANGUAGE_GLSL;
renderer->shader_version = SDL_GPU_GLSL_VERSION;
renderer->current_context_target = NULL;
SET_COMMON_FUNCTIONS(renderer);
return renderer;
}
void GPU_FreeRenderer_OpenGL_3(GPU_Renderer* renderer)
{
if(renderer == NULL)
return;
free(renderer);
}
#endif

139
src/SDL_gpu/SDL_gpu/OpenGL_3/SDL_gpu_OpenGL_3.h Normal file
View file

@ -0,0 +1,139 @@
#ifndef _SDL_GPU_OPENGL_3_H__
#define _SDL_GPU_OPENGL_3_H__
#include "SDL_gpu.h"
#if !defined(SDL_GPU_DISABLE_OPENGL) && !defined(SDL_GPU_DISABLE_OPENGL_3)
// Hacks to fix compile errors due to polluted namespace
#ifdef _WIN32
#define _WINUSER_H
#define _WINGDI_H
#endif
#include "glew.h"
#if defined(GL_EXT_bgr) && !defined(GL_BGR)
#define GL_BGR GL_BGR_EXT
#endif
#if defined(GL_EXT_bgra) && !defined(GL_BGRA)
#define GL_BGRA GL_BGRA_EXT
#endif
#if defined(GL_EXT_abgr) && !defined(GL_ABGR)
#define GL_ABGR GL_ABGR_EXT
#endif
#endif
#define GPU_CONTEXT_DATA ContextData_OpenGL_3
#define GPU_IMAGE_DATA ImageData_OpenGL_3
#define GPU_TARGET_DATA TargetData_OpenGL_3
#define GPU_DEFAULT_TEXTURED_VERTEX_SHADER_SOURCE \
"#version 130\n\
\
in vec2 gpu_Vertex;\n\
in vec2 gpu_TexCoord;\n\
in vec4 gpu_Color;\n\
uniform mat4 gpu_ModelViewProjectionMatrix;\n\
\
out vec4 color;\n\
out vec2 texCoord;\n\
\
void main(void)\n\
{\n\
color = gpu_Color;\n\
texCoord = vec2(gpu_TexCoord);\n\
gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
}"
// Tier 3 uses shader attributes to send position, texcoord, and color data for each vertex.
#define GPU_DEFAULT_UNTEXTURED_VERTEX_SHADER_SOURCE \
"#version 130\n\
\
in vec2 gpu_Vertex;\n\
in vec4 gpu_Color;\n\
uniform mat4 gpu_ModelViewProjectionMatrix;\n\
\
out vec4 color;\n\
\
void main(void)\n\
{\n\
color = gpu_Color;\n\
gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
}"
#define GPU_DEFAULT_TEXTURED_FRAGMENT_SHADER_SOURCE \
"#version 130\n\
\
in vec4 color;\n\
in vec2 texCoord;\n\
\
uniform sampler2D tex;\n\
\
void main(void)\n\
{\n\
gl_FragColor = texture2D(tex, texCoord) * color;\n\
}"
#define GPU_DEFAULT_UNTEXTURED_FRAGMENT_SHADER_SOURCE \
"#version 130\n\
\
in vec4 color;\n\
\
void main(void)\n\
{\n\
gl_FragColor = color;\n\
}"
typedef struct ContextData_OpenGL_3
{
SDL_Color last_color;
Uint8 last_use_texturing;
unsigned int last_shape;
Uint8 last_use_blending;
GPU_BlendMode last_blend_mode;
GPU_Rect last_viewport;
GPU_Camera last_camera;
Uint8 last_camera_inverted;
GPU_Image* last_image;
GPU_Target* last_target;
float* blit_buffer; // Holds sets of 4 vertices, each with interleaved position, tex coords, and colors (e.g. [x0, y0, z0, s0, t0, r0, g0, b0, a0, ...]).
unsigned short blit_buffer_num_vertices;
unsigned short blit_buffer_max_num_vertices;
unsigned short* index_buffer; // Indexes into the blit buffer so we can use 4 vertices for every 2 triangles (1 quad)
unsigned int index_buffer_num_vertices;
unsigned int index_buffer_max_num_vertices;
// Tier 3 rendering
unsigned int blit_VAO;
unsigned int blit_VBO[2]; // For double-buffering
Uint8 blit_VBO_flop;
GPU_ShaderBlock shader_block[2];
GPU_ShaderBlock current_shader_block;
GPU_AttributeSource shader_attributes[16];
unsigned int attribute_VBO[16];
} ContextData_OpenGL_3;
typedef struct ImageData_OpenGL_3
{
int refcount;
Uint32 handle;
Uint32 format;
} ImageData_OpenGL_3;
typedef struct TargetData_OpenGL_3
{
int refcount;
Uint32 handle;
Uint32 format;
} TargetData_OpenGL_3;
#endif

2521
src/SDL_gpu/SDL_gpu/SDL_gpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1593
src/SDL_gpu/SDL_gpu/SDL_gpu.h Normal file
View file

File diff suppressed because it is too large Load diff

3
src/SDL_gpu/SDL_gpu/SDL_gpuConfig.cmake Normal file
View file

@ -0,0 +1,3 @@
get_filename_component(SELF_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
include(${SELF_DIR}/SDL_gpu-targets.cmake)

173
src/SDL_gpu/SDL_gpu/SDL_gpuShapes.c Normal file
View file

@ -0,0 +1,173 @@
#include "SDL_gpu.h"
#include <string.h>
#define CHECK_RENDERER(ret) \
GPU_Renderer* renderer = GPU_GetCurrentRenderer(); \
if(renderer == NULL) \
return ret;
float GPU_SetLineThickness(float thickness)
{
CHECK_RENDERER(1.0f);
if(renderer->SetLineThickness == NULL)
return 1.0f;
return renderer->SetLineThickness(renderer, thickness);
}
float GPU_GetLineThickness(void)
{
CHECK_RENDERER(1.0f);
if(renderer->GetLineThickness == NULL)
return 1.0f;
return renderer->GetLineThickness(renderer);
}
void GPU_Pixel(GPU_Target* target, float x, float y, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->Pixel == NULL)
return;
renderer->Pixel(renderer, target, x, y, color);
}
void GPU_Line(GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->Line == NULL)
return;
renderer->Line(renderer, target, x1, y1, x2, y2, color);
}
void GPU_Arc(GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->Arc == NULL)
return;
renderer->Arc(renderer, target, x, y, radius, start_angle, end_angle, color);
}
void GPU_ArcFilled(GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->ArcFilled == NULL)
return;
renderer->ArcFilled(renderer, target, x, y, radius, start_angle, end_angle, color);
}
void GPU_Circle(GPU_Target* target, float x, float y, float radius, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->Circle == NULL)
return;
renderer->Circle(renderer, target, x, y, radius, color);
}
void GPU_CircleFilled(GPU_Target* target, float x, float y, float radius, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->CircleFilled == NULL)
return;
renderer->CircleFilled(renderer, target, x, y, radius, color);
}
void GPU_Sector(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->Sector == NULL)
return;
renderer->Sector(renderer, target, x, y, inner_radius, outer_radius, start_angle, end_angle, color);
}
void GPU_SectorFilled(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->SectorFilled == NULL)
return;
renderer->SectorFilled(renderer, target, x, y, inner_radius, outer_radius, start_angle, end_angle, color);
}
void GPU_Tri(GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->Tri == NULL)
return;
renderer->Tri(renderer, target, x1, y1, x2, y2, x3, y3, color);
}
void GPU_TriFilled(GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->TriFilled == NULL)
return;
renderer->TriFilled(renderer, target, x1, y1, x2, y2, x3, y3, color);
}
void GPU_Rectangle(GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->Rectangle == NULL)
return;
renderer->Rectangle(renderer, target, x1, y1, x2, y2, color);
}
void GPU_RectangleFilled(GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->RectangleFilled == NULL)
return;
renderer->RectangleFilled(renderer, target, x1, y1, x2, y2, color);
}
void GPU_RectangleRound(GPU_Target* target, float x1, float y1, float x2, float y2, float radius, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->RectangleRound == NULL)
return;
renderer->RectangleRound(renderer, target, x1, y1, x2, y2, radius, color);
}
void GPU_RectangleRoundFilled(GPU_Target* target, float x1, float y1, float x2, float y2, float radius, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->RectangleRoundFilled == NULL)
return;
renderer->RectangleRoundFilled(renderer, target, x1, y1, x2, y2, radius, color);
}
void GPU_Polygon(GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->Polygon == NULL)
return;
renderer->Polygon(renderer, target, num_vertices, vertices, color);
}
void GPU_PolygonFilled(GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color)
{
CHECK_RENDERER();
if(renderer->PolygonFilled == NULL)
return;
renderer->PolygonFilled(renderer, target, num_vertices, vertices, color);
}

422
src/SDL_gpu/SDL_gpu/SDL_gpu_Renderer.c Normal file
View file

@ -0,0 +1,422 @@
#include "SDL_gpu.h"
#include "SDL_platform.h"
#include <string.h>
#ifndef _MSC_VER
#include <strings.h>
#else
#define __func__ __FUNCTION__
#endif
#define MAX_ACTIVE_RENDERERS 20
#define MAX_REGISTERED_RENDERERS 10
typedef struct RendererRegistration
{
GPU_RendererID id;
GPU_Renderer* (*createFn)(GPU_RendererID request);
void (*freeFn)(GPU_Renderer*);
} RendererRegistration;
static Uint8 initialized = 0;
static GPU_Renderer* rendererMap[MAX_ACTIVE_RENDERERS];
static RendererRegistration rendererRegister[MAX_REGISTERED_RENDERERS];
static GPU_RendererID makeRendererID(GPU_RendererEnum id, int major_version, int minor_version, int index)
{
GPU_RendererID r = {id, major_version, minor_version, index};
return r;
}
void GPU_InitRendererRegister(void);
int GPU_GetNumActiveRenderers(void)
{
int count;
int i;
GPU_InitRendererRegister();
count = 0;
for(i = 0; i < MAX_ACTIVE_RENDERERS; i++)
{
if(rendererMap[i] != NULL)
count++;
}
return count;
}
void GPU_GetActiveRendererList(GPU_RendererID* renderers_array)
{
int count;
int i;
GPU_InitRendererRegister();
count = 0;
for(i = 0; i < MAX_ACTIVE_RENDERERS; i++)
{
if(rendererMap[i] != NULL)
{
renderers_array[count] = rendererMap[i]->id;
count++;
}
}
}
int GPU_GetNumRegisteredRenderers(void)
{
int count;
int i;
GPU_InitRendererRegister();
count = 0;
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
{
if(rendererRegister[i].id.id != GPU_RENDERER_UNKNOWN)
count++;
}
return count;
}
void GPU_GetRegisteredRendererList(GPU_RendererID* renderers_array)
{
int count;
int i;
GPU_InitRendererRegister();
count = 0;
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
{
if(rendererRegister[i].id.id != GPU_RENDERER_UNKNOWN)
{
renderers_array[count] = rendererRegister[i].id;
count++;
}
}
}
GPU_RendererID GPU_GetRendererID(unsigned int index)
{
if(index >= MAX_REGISTERED_RENDERERS)
return makeRendererID(GPU_RENDERER_UNKNOWN, 0, 0, -1);
return rendererRegister[index].id;
}
GPU_Renderer* GPU_CreateRenderer_OpenGL_1_BASE(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_1_BASE(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_OpenGL_1(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_1(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_OpenGL_2(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_2(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_OpenGL_3(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_3(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_GLES_1(GPU_RendererID request);
void GPU_FreeRenderer_GLES_1(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_GLES_2(GPU_RendererID request);
void GPU_FreeRenderer_GLES_2(GPU_Renderer* renderer);
void GPU_RegisterRenderers()
{
int i = 0;
if(i >= MAX_REGISTERED_RENDERERS)
return;
#ifndef SDL_GPU_DISABLE_OPENGL
#ifndef SDL_GPU_DISABLE_OPENGL_1_BASE
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_1_BASE, 1, 1, i);
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_1_BASE;
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_1_BASE;
i++;
if(i >= MAX_REGISTERED_RENDERERS)
return;
#endif
#ifndef SDL_GPU_DISABLE_OPENGL_1
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_1, 1, 1, i);
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_1;
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_1;
i++;
if(i >= MAX_REGISTERED_RENDERERS)
return;
#endif
#ifndef SDL_GPU_DISABLE_OPENGL_2
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_2, 2, 0, i);
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_2;
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_2;
i++;
if(i >= MAX_REGISTERED_RENDERERS)
return;
#endif
#ifndef SDL_GPU_DISABLE_OPENGL_3
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_3, 3, 0, i);
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_3;
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_3;
i++;
if(i >= MAX_REGISTERED_RENDERERS)
return;
#endif
#endif
#ifndef SDL_GPU_DISABLE_GLES
#ifndef SDL_GPU_DISABLE_GLES_1
rendererRegister[i].id = makeRendererID(GPU_RENDERER_GLES_1, 1, 1, i);
rendererRegister[i].createFn = &GPU_CreateRenderer_GLES_1;
rendererRegister[i].freeFn = &GPU_FreeRenderer_GLES_1;
i++;
if(i >= MAX_REGISTERED_RENDERERS)
return;
#endif
#ifndef SDL_GPU_DISABLE_GLES_2
rendererRegister[i].id = makeRendererID(GPU_RENDERER_GLES_2, 2, 0, i);
rendererRegister[i].createFn = &GPU_CreateRenderer_GLES_2;
rendererRegister[i].freeFn = &GPU_FreeRenderer_GLES_2;
i++;
if(i >= MAX_REGISTERED_RENDERERS)
return;
#endif
#endif
}
static int renderer_order_size = 0;
static GPU_RendererID renderer_order[GPU_RENDERER_ORDER_MAX];
void GPU_InitRendererRegister(void)
{
int i;
if(initialized)
return;
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
{
rendererRegister[i].id.id = GPU_RENDERER_UNKNOWN;
rendererRegister[i].id.index = i;
rendererRegister[i].createFn = NULL;
rendererRegister[i].freeFn = NULL;
}
for(i = 0; i < MAX_ACTIVE_RENDERERS; i++)
{
rendererMap[i] = NULL;
}
GPU_GetDefaultRendererOrder(&renderer_order_size, renderer_order);
initialized = 1;
GPU_RegisterRenderers();
}
void GPU_GetRendererOrder(int* order_size, GPU_RendererID* order)
{
if(order_size != NULL)
*order_size = renderer_order_size;
if(order != NULL && renderer_order_size > 0)
memcpy(order, renderer_order, renderer_order_size*sizeof(GPU_RendererID));
}
void GPU_SetRendererOrder(int order_size, GPU_RendererID* order)
{
if(order == NULL)
{
// Restore the default order
int count = 0;
GPU_RendererID default_order[GPU_RENDERER_ORDER_MAX];
GPU_GetDefaultRendererOrder(&count, default_order);
GPU_SetRendererOrder(count, default_order); // Call us again with the default order
return;
}
if(order_size <= 0)
return;
if(order_size > GPU_RENDERER_ORDER_MAX)
{
GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "Given order_size (%d) is greater than GPU_RENDERER_ORDER_MAX (%d)", order_size, GPU_RENDERER_ORDER_MAX);
order_size = GPU_RENDERER_ORDER_MAX;
}
memcpy(renderer_order, order, order_size*sizeof(GPU_RendererID));
renderer_order_size = order_size;
}
void GPU_GetDefaultRendererOrder(int* order_size, GPU_RendererID* order)
{
int count = 0;
GPU_RendererID default_order[GPU_RENDERER_ORDER_MAX];
#if defined(__ANDROID__) || defined(__IPHONEOS__)
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_GLES_2, 2, 0);
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_GLES_1, 1, 1);
#else
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_3, 3, 0);
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_2, 2, 0);
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_1, 1, 1);
#endif
if(order_size != NULL)
*order_size = count;
if(order != NULL && count > 0)
memcpy(order, default_order, count*sizeof(GPU_RendererID));
}
const char* GPU_GetRendererEnumString(GPU_RendererEnum id)
{
if(id == GPU_RENDERER_OPENGL_1_BASE)
return "OpenGL 1 BASE";
if(id == GPU_RENDERER_OPENGL_1)
return "OpenGL 1.x";
if(id == GPU_RENDERER_OPENGL_2)
return "OpenGL 2.x";
if(id == GPU_RENDERER_OPENGL_3)
return "OpenGL 3.x";
if(id == GPU_RENDERER_OPENGL_4)
return "OpenGL 4.x";
if(id == GPU_RENDERER_GLES_1)
return "OpenGLES 1.x";
if(id == GPU_RENDERER_GLES_2)
return "OpenGLES 2.x";
if(id == GPU_RENDERER_GLES_3)
return "OpenGLES 3.x";
if(id == GPU_RENDERER_D3D9)
return "Direct3D 9";
if(id == GPU_RENDERER_D3D10)
return "Direct3D 10";
if(id == GPU_RENDERER_D3D11)
return "Direct3D 11";
return "Unknown";
}
GPU_Renderer* GPU_CreateRenderer(GPU_RendererID id)
{
GPU_Renderer* result = NULL;
int i;
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
{
if(rendererRegister[i].id.id == GPU_RENDERER_UNKNOWN)
continue;
if(id.id == rendererRegister[i].id.id)
{
if(rendererRegister[i].createFn != NULL)
{
result = rendererRegister[i].createFn(id);
}
break;
}
}
if(result == NULL)
{
GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Renderer was not found in the renderer registry.");
}
return result;
}
GPU_Renderer* GPU_GetRenderer(unsigned int index)
{
if(index >= MAX_ACTIVE_RENDERERS)
return NULL;
return rendererMap[index];
}
// Get a renderer from the map.
GPU_Renderer* GPU_GetRendererByID(GPU_RendererID id)
{
GPU_InitRendererRegister();
if(id.index < 0)
return NULL;
return GPU_GetRenderer(id.index);
}
// Create a new renderer based on a registered id and store it in the map.
GPU_Renderer* GPU_AddRenderer(GPU_RendererID id)
{
int i;
for(i = 0; i < MAX_ACTIVE_RENDERERS; i++)
{
if(rendererMap[i] == NULL)
{
// Create
GPU_Renderer* renderer = GPU_CreateRenderer(id);
if(renderer == NULL)
{
GPU_PushErrorCode(__func__, GPU_ERROR_BACKEND_ERROR, "Failed to create new renderer.");
return NULL;
}
// Add
rendererMap[i] = renderer;
renderer->id.index = i;
// Return
return renderer;
}
}
return NULL;
}
void GPU_FreeRenderer(GPU_Renderer* renderer)
{
int i;
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
{
if(rendererRegister[i].id.id == GPU_RENDERER_UNKNOWN)
continue;
if(renderer->id.id == rendererRegister[i].id.id)
{
rendererRegister[i].freeFn(renderer);
return;
}
}
}
// Remove a renderer from the map and free it.
void GPU_RemoveRenderer(GPU_RendererID id)
{
int i;
for(i = 0; i < MAX_ACTIVE_RENDERERS; i++)
{
if(rendererMap[i] == NULL)
continue;
if(i == id.index && id.id == rendererMap[i]->id.id)
{
GPU_FreeRenderer(rendererMap[i]);
rendererMap[i] = NULL;
return;
}
}
}

15484
src/SDL_gpu/SDL_gpu/externals/glew/glew.c vendored Normal file
View file

File diff suppressed because it is too large Load diff

15510
src/SDL_gpu/SDL_gpu/externals/glew/glew.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

1568
src/SDL_gpu/SDL_gpu/externals/glew/glxew.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

1361
src/SDL_gpu/SDL_gpu/externals/glew/wglew.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

4673
src/SDL_gpu/SDL_gpu/externals/stb_image/stb_image.c vendored Normal file
View file

File diff suppressed because it is too large Load diff

7
src/SDL_gpu/SDL_gpu/externals/stb_image/stb_image.h vendored Normal file
View file

@ -0,0 +1,7 @@
#ifndef STBI_INCLUDE_STB_IMAGE_H_WRAPPER
#define STBI_INCLUDE_STB_IMAGE_H_WRAPPER
#define STBI_HEADER_FILE_ONLY
#include "stb_image.c"
#endif

3
src/SDL_gpu/SDL_gpu/externals/stb_image/stb_image_write.c vendored Normal file
View file

@ -0,0 +1,3 @@
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"

511
src/SDL_gpu/SDL_gpu/externals/stb_image/stb_image_write.h vendored Normal file
View file

@ -0,0 +1,511 @@
/* stbiw-0.92 - public domain - http://nothings.org/stb/stb_image_write.h
writes out PNG/BMP/TGA images to C stdio - Sean Barrett 2010
no warranty implied; use at your own risk
Before including,
#define STB_IMAGE_WRITE_IMPLEMENTATION
in the file that you want to have the implementation.
ABOUT:
This header file is a library for writing images to C stdio. It could be
adapted to write to memory or a general streaming interface; let me know.
The PNG output is not optimal; it is 20-50% larger than the file
written by a decent optimizing implementation. This library is designed
for source code compactness and simplicity, not optimal image file size
or run-time performance.
USAGE:
There are three functions, one for each image file format:
int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
Each function returns 0 on failure and non-0 on success.
The functions create an image file defined by the parameters. The image
is a rectangle of pixels stored from left-to-right, top-to-bottom.
Each pixel contains 'comp' channels of data stored interleaved with 8-bits
per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
The *data pointer points to the first byte of the top-left-most pixel.
For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
a row of pixels to the first byte of the next row of pixels.
PNG creates output files with the same number of components as the input.
The BMP and TGA formats expand Y to RGB in the file format. BMP does not
output alpha.
PNG supports writing rectangles of data even when the bytes storing rows of
data are not consecutive in memory (e.g. sub-rectangles of a larger image),
by supplying the stride between the beginning of adjacent rows. The other
formats do not. (Thus you cannot write a native-format BMP through the BMP
writer, both because it is in BGR order and because it may have padding
at the end of the line.)
*/
#ifndef INCLUDE_STB_IMAGE_WRITE_H
#define INCLUDE_STB_IMAGE_WRITE_H
#ifdef __cplusplus
extern "C" {
#endif
extern int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
extern int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
extern int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
#ifdef __cplusplus
}
#endif
#endif//INCLUDE_STB_IMAGE_WRITE_H
#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef unsigned int stbiw_uint32;
typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
static void writefv(FILE *f, const char *fmt, va_list v)
{
while (*fmt) {
switch (*fmt++) {
case ' ': break;
case '1': { unsigned char x = (unsigned char) va_arg(v, int); fputc(x,f); break; }
case '2': { int x = va_arg(v,int); unsigned char b[2];
b[0] = (unsigned char) x; b[1] = (unsigned char) (x>>8);
fwrite(b,2,1,f); break; }
case '4': { stbiw_uint32 x = va_arg(v,int); unsigned char b[4];
b[0]=(unsigned char)x; b[1]=(unsigned char)(x>>8);
b[2]=(unsigned char)(x>>16); b[3]=(unsigned char)(x>>24);
fwrite(b,4,1,f); break; }
default:
assert(0);
return;
}
}
}
static void write3(FILE *f, unsigned char a, unsigned char b, unsigned char c)
{
unsigned char arr[3];
arr[0] = a, arr[1] = b, arr[2] = c;
fwrite(arr, 3, 1, f);
}
static void write_pixels(FILE *f, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad)
{
unsigned char bg[3] = { 255, 0, 255}, px[3];
stbiw_uint32 zero = 0;
int i,j,k, j_end;
if (y <= 0)
return;
if (vdir < 0)
j_end = -1, j = y-1;
else
j_end = y, j = 0;
for (; j != j_end; j += vdir) {
for (i=0; i < x; ++i) {
unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
if (write_alpha < 0)
fwrite(&d[comp-1], 1, 1, f);
switch (comp) {
case 1:
case 2: write3(f, d[0],d[0],d[0]);
break;
case 4:
if (!write_alpha) {
// composite against pink background
for (k=0; k < 3; ++k)
px[k] = bg[k] + ((d[k] - bg[k]) * d[3])/255;
write3(f, px[1-rgb_dir],px[1],px[1+rgb_dir]);
break;
}
/* FALLTHROUGH */
case 3:
write3(f, d[1-rgb_dir],d[1],d[1+rgb_dir]);
break;
}
if (write_alpha > 0)
fwrite(&d[comp-1], 1, 1, f);
}
fwrite(&zero,scanline_pad,1,f);
}
}
static int outfile(char const *filename, int rgb_dir, int vdir, int x, int y, int comp, void *data, int alpha, int pad, const char *fmt, ...)
{
FILE *f;
if (y < 0 || x < 0) return 0;
f = fopen(filename, "wb");
if (f) {
va_list v;
va_start(v, fmt);
writefv(f, fmt, v);
va_end(v);
write_pixels(f,rgb_dir,vdir,x,y,comp,data,alpha,pad);
fclose(f);
}
return f != NULL;
}
int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
int pad = (-x*3) & 3;
return outfile(filename,-1,-1,x,y,comp,(void *) data,0,pad,
"11 4 22 4" "4 44 22 444444",
'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header
40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header
}
int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
int has_alpha = !(comp & 1);
return outfile(filename, -1,-1, x, y, comp, (void *) data, has_alpha, 0,
"111 221 2222 11", 0,0,2, 0,0,0, 0,0,x,y, 24+8*has_alpha, 8*has_alpha);
}
// stretchy buffer; stbi__sbpush() == vector<>::push_back() -- stbi__sbcount() == vector<>::size()
#define stbi__sbraw(a) ((int *) (a) - 2)
#define stbi__sbm(a) stbi__sbraw(a)[0]
#define stbi__sbn(a) stbi__sbraw(a)[1]
#define stbi__sbneedgrow(a,n) ((a)==0 || stbi__sbn(a)+n >= stbi__sbm(a))
#define stbi__sbmaybegrow(a,n) (stbi__sbneedgrow(a,(n)) ? stbi__sbgrow(a,n) : 0)
#define stbi__sbgrow(a,n) stbi__sbgrowf((void **) &(a), (n), sizeof(*(a)))
#define stbi__sbpush(a, v) (stbi__sbmaybegrow(a,1), (a)[stbi__sbn(a)++] = (v))
#define stbi__sbcount(a) ((a) ? stbi__sbn(a) : 0)
#define stbi__sbfree(a) ((a) ? free(stbi__sbraw(a)),0 : 0)
static void *stbi__sbgrowf(void **arr, int increment, int itemsize)
{
int m = *arr ? 2*stbi__sbm(*arr)+increment : increment+1;
void *p = realloc(*arr ? stbi__sbraw(*arr) : 0, itemsize * m + sizeof(int)*2);
assert(p);
if (p) {
if (!*arr) ((int *) p)[1] = 0;
*arr = (void *) ((int *) p + 2);
stbi__sbm(*arr) = m;
}
return *arr;
}
static unsigned char *stbi__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
while (*bitcount >= 8) {
stbi__sbpush(data, (unsigned char) *bitbuffer);
*bitbuffer >>= 8;
*bitcount -= 8;
}
return data;
}
static int stbi__zlib_bitrev(int code, int codebits)
{
int res=0;
while (codebits--) {
res = (res << 1) | (code & 1);
code >>= 1;
}
return res;
}
static unsigned int stbi__zlib_countm(unsigned char *a, unsigned char *b, int limit)
{
int i;
for (i=0; i < limit && i < 258; ++i)
if (a[i] != b[i]) break;
return i;
}
static unsigned int stbi__zhash(unsigned char *data)
{
stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
hash ^= hash << 3;
hash += hash >> 5;
hash ^= hash << 4;
hash += hash >> 17;
hash ^= hash << 25;
hash += hash >> 6;
return hash;
}
#define stbi__zlib_flush() (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))
#define stbi__zlib_add(code,codebits) \
(bitbuf |= (code) << bitcount, bitcount += (codebits), stbi__zlib_flush())
#define stbi__zlib_huffa(b,c) stbi__zlib_add(stbi__zlib_bitrev(b,c),c)
// default huffman tables
#define stbi__zlib_huff1(n) stbi__zlib_huffa(0x30 + (n), 8)
#define stbi__zlib_huff2(n) stbi__zlib_huffa(0x190 + (n)-144, 9)
#define stbi__zlib_huff3(n) stbi__zlib_huffa(0 + (n)-256,7)
#define stbi__zlib_huff4(n) stbi__zlib_huffa(0xc0 + (n)-280,8)
#define stbi__zlib_huff(n) ((n) <= 143 ? stbi__zlib_huff1(n) : (n) <= 255 ? stbi__zlib_huff2(n) : (n) <= 279 ? stbi__zlib_huff3(n) : stbi__zlib_huff4(n))
#define stbi__zlib_huffb(n) ((n) <= 143 ? stbi__zlib_huff1(n) : stbi__zlib_huff2(n))
#define stbi__ZHASH 16384
unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
{
static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 };
static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
unsigned int bitbuf=0;
int i,j, bitcount=0;
unsigned char *out = NULL;
unsigned char **hash_table[stbi__ZHASH]; // 64KB on the stack!
if (quality < 5) quality = 5;
stbi__sbpush(out, 0x78); // DEFLATE 32K window
stbi__sbpush(out, 0x5e); // FLEVEL = 1
stbi__zlib_add(1,1); // BFINAL = 1
stbi__zlib_add(1,2); // BTYPE = 1 -- fixed huffman
for (i=0; i < stbi__ZHASH; ++i)
hash_table[i] = NULL;
i=0;
while (i < data_len-3) {
// hash next 3 bytes of data to be compressed
int h = stbi__zhash(data+i)&(stbi__ZHASH-1), best=3;
unsigned char *bestloc = 0;
unsigned char **hlist = hash_table[h];
int n = stbi__sbcount(hlist);
for (j=0; j < n; ++j) {
if (hlist[j]-data > i-32768) { // if entry lies within window
int d = stbi__zlib_countm(hlist[j], data+i, data_len-i);
if (d >= best) best=d,bestloc=hlist[j];
}
}
// when hash table entry is too long, delete half the entries
if (hash_table[h] && stbi__sbn(hash_table[h]) == 2*quality) {
memcpy(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
stbi__sbn(hash_table[h]) = quality;
}
stbi__sbpush(hash_table[h],data+i);
if (bestloc) {
// "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
h = stbi__zhash(data+i+1)&(stbi__ZHASH-1);
hlist = hash_table[h];
n = stbi__sbcount(hlist);
for (j=0; j < n; ++j) {
if (hlist[j]-data > i-32767) {
int e = stbi__zlib_countm(hlist[j], data+i+1, data_len-i-1);
if (e > best) { // if next match is better, bail on current match
bestloc = NULL;
break;
}
}
}
}
if (bestloc) {
int d = (int)(data+i - bestloc); // distance back
assert(d <= 32767 && best <= 258);
for (j=0; best > lengthc[j+1]-1; ++j);
stbi__zlib_huff(j+257);
if (lengtheb[j]) stbi__zlib_add(best - lengthc[j], lengtheb[j]);
for (j=0; d > distc[j+1]-1; ++j);
stbi__zlib_add(stbi__zlib_bitrev(j,5),5);
if (disteb[j]) stbi__zlib_add(d - distc[j], disteb[j]);
i += best;
} else {
stbi__zlib_huffb(data[i]);
++i;
}
}
// write out final bytes
for (;i < data_len; ++i)
stbi__zlib_huffb(data[i]);
stbi__zlib_huff(256); // end of block
// pad with 0 bits to byte boundary
while (bitcount)
stbi__zlib_add(0,1);
for (i=0; i < stbi__ZHASH; ++i)
(void) stbi__sbfree(hash_table[i]);
{
// compute adler32 on input
unsigned int i=0, s1=1, s2=0, blocklen = data_len % 5552;
int j=0;
while (j < data_len) {
for (i=0; i < blocklen; ++i) s1 += data[j+i], s2 += s1;
s1 %= 65521, s2 %= 65521;
j += blocklen;
blocklen = 5552;
}
stbi__sbpush(out, (unsigned char) (s2 >> 8));
stbi__sbpush(out, (unsigned char) s2);
stbi__sbpush(out, (unsigned char) (s1 >> 8));
stbi__sbpush(out, (unsigned char) s1);
}
*out_len = stbi__sbn(out);
// make returned pointer freeable
memmove(stbi__sbraw(out), out, *out_len);
return (unsigned char *) stbi__sbraw(out);
}
unsigned int stbi__crc32(unsigned char *buffer, int len)
{
static unsigned int crc_table[256];
unsigned int crc = ~0u;
int i,j;
if (crc_table[1] == 0)
for(i=0; i < 256; i++)
for (crc_table[i]=i, j=0; j < 8; ++j)
crc_table[i] = (crc_table[i] >> 1) ^ (crc_table[i] & 1 ? 0xedb88320 : 0);
for (i=0; i < len; ++i)
crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
return ~crc;
}
#define stbi__wpng4(o,a,b,c,d) ((o)[0]=(unsigned char)(a),(o)[1]=(unsigned char)(b),(o)[2]=(unsigned char)(c),(o)[3]=(unsigned char)(d),(o)+=4)
#define stbi__wp32(data,v) stbi__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
#define stbi__wptag(data,s) stbi__wpng4(data, s[0],s[1],s[2],s[3])
static void stbi__wpcrc(unsigned char **data, int len)
{
unsigned int crc = stbi__crc32(*data - len - 4, len+4);
stbi__wp32(*data, crc);
}
static unsigned char stbi__paeth(int a, int b, int c)
{
int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
if (pa <= pb && pa <= pc) return (unsigned char) a;
if (pb <= pc) return (unsigned char) b;
return (unsigned char) c;
}
unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
{
int ctype[5] = { -1, 0, 4, 2, 6 };
unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
unsigned char *out,*o, *filt, *zlib;
signed char *line_buffer;
int i,j,k,p,zlen;
if (stride_bytes == 0)
stride_bytes = x * n;
filt = (unsigned char *) malloc((x*n+1) * y); if (!filt) return 0;
line_buffer = (signed char *) malloc(x * n); if (!line_buffer) { free(filt); return 0; }
for (j=0; j < y; ++j) {
static int mapping[] = { 0,1,2,3,4 };
static int firstmap[] = { 0,1,0,5,6 };
int *mymap = j ? mapping : firstmap;
int best = 0, bestval = 0x7fffffff;
for (p=0; p < 2; ++p) {
for (k= p?best:0; k < 5; ++k) {
int type = mymap[k],est=0;
unsigned char *z = pixels + stride_bytes*j;
for (i=0; i < n; ++i)
switch (type) {
case 0: line_buffer[i] = z[i]; break;
case 1: line_buffer[i] = z[i]; break;
case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
case 3: line_buffer[i] = z[i] - (z[i-stride_bytes]>>1); break;
case 4: line_buffer[i] = (signed char) (z[i] - stbi__paeth(0,z[i-stride_bytes],0)); break;
case 5: line_buffer[i] = z[i]; break;
case 6: line_buffer[i] = z[i]; break;
}
for (i=n; i < x*n; ++i) {
switch (type) {
case 0: line_buffer[i] = z[i]; break;
case 1: line_buffer[i] = z[i] - z[i-n]; break;
case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
case 3: line_buffer[i] = z[i] - ((z[i-n] + z[i-stride_bytes])>>1); break;
case 4: line_buffer[i] = z[i] - stbi__paeth(z[i-n], z[i-stride_bytes], z[i-stride_bytes-n]); break;
case 5: line_buffer[i] = z[i] - (z[i-n]>>1); break;
case 6: line_buffer[i] = z[i] - stbi__paeth(z[i-n], 0,0); break;
}
}
if (p) break;
for (i=0; i < x*n; ++i)
est += abs((signed char) line_buffer[i]);
if (est < bestval) { bestval = est; best = k; }
}
}
// when we get here, best contains the filter type, and line_buffer contains the data
filt[j*(x*n+1)] = (unsigned char) best;
memcpy(filt+j*(x*n+1)+1, line_buffer, x*n);
}
free(line_buffer);
zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, 8); // increase 8 to get smaller but use more memory
free(filt);
if (!zlib) return 0;
// each tag requires 12 bytes of overhead
out = (unsigned char *) malloc(8 + 12+13 + 12+zlen + 12);
if (!out) return 0;
*out_len = 8 + 12+13 + 12+zlen + 12;
o=out;
memcpy(o,sig,8); o+= 8;
stbi__wp32(o, 13); // header length
stbi__wptag(o, "IHDR");
stbi__wp32(o, x);
stbi__wp32(o, y);
*o++ = 8;
*o++ = (unsigned char) ctype[n];
*o++ = 0;
*o++ = 0;
*o++ = 0;
stbi__wpcrc(&o,13);
stbi__wp32(o, zlen);
stbi__wptag(o, "IDAT");
memcpy(o, zlib, zlen); o += zlen; free(zlib);
stbi__wpcrc(&o, zlen);
stbi__wp32(o,0);
stbi__wptag(o, "IEND");
stbi__wpcrc(&o,0);
assert(o == out + *out_len);
return out;
}
int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
FILE *f;
int len;
unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
if (!png) return 0;
f = fopen(filename, "wb");
if (!f) { free(png); return 0; }
fwrite(png, 1, len, f);
fclose(f);
free(png);
return 1;
}
#endif // STB_IMAGE_WRITE_IMPLEMENTATION
/* Revision history
0.92 (2010-08-01)
casts to unsigned char to fix warnings
0.91 (2010-07-17)
first public release
0.90 first internal release
*/

58
src/SDL_gpu/SDL_gpu/mainpage.dox Normal file
View file

@ -0,0 +1,58 @@
/*!
\mainpage
SDL_gpu is a C code library for making hardware-accelerated 2D graphics easy.
SDL_gpu is licensed under the terms of the MIT License.
See LICENSE.txt for details of the usage license granted to you for this code.
\section latest_source LATEST SOURCE
SDL_gpu is hosted on Google Code (http://code.google.com/p/sdl-gpu). You can check out the latest version of the source code with Subversion:
svn checkout http://sdl-gpu.googlecode.com/svn/trunk/ sdl-gpu
To check out everything, including the pre-generated documentation:
svn checkout http://sdl-gpu.googlecode.com/svn/ sdl-gpu
For just the current library code, use:
svn checkout http://sdl-gpu.googlecode.com/svn/trunk/ sdl-gpu
\section dependencies DEPENDENCIES
SDL 1.2 or SDL 2.0 (www.libsdl.org)
A rendering backend
Currently implemented: OpenGL 1.1, OpenGL 2.0, OpenGL 3.0, OpenGL ES 1.1, OpenGL ES 2.0
\section building BUILDING
SDL_gpu uses CMake (www.cmake.org) to coordinate the library build process. CMake is available as a GUI program or on the command line.
For Linux/UNIX systems, run CMake in the base directory:
cmake -G "Unix Makefiles"
make
sudo make install
For Linux/UNIX systems, changing the default installation directory can be done like so:
cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX=/usr
For Windows systems, you can use cmake-gui and select appropriate options in there (warning: cmake-gui is messy!).
\section including_linking INCLUDING / LINKING
Add the include for SDL_gpu.h to your sources. Link to SDL_gpu (libSDL_gpu.a) or SDL2_gpu (if you use SDL2).
\section documentation DOCUMENTATION
Documentation is automatically generated with Doxygen (http://sourceforge.net/projects/doxygen).
Pre-generated documentation can be found in the repository's base documentation directory.
*/