This implies creating a trimmed down branch that contains almost nothing. It will then be usable by projects that do not need the complex build system, and by the engine itself as a submodule from the same repository.wip/core-clipp
@@ -1,150 +1,3 @@ | |||
# Autotools cruft | |||
*.o | |||
*.lo | |||
*.a | |||
*.la | |||
*.exe | |||
*.so | |||
*.elf | |||
*.self | |||
*.nexe | |||
*.userprefs | |||
*.usertasks | |||
*.pidb | |||
.auto | |||
.libs | |||
.deps | |||
.dirstamp | |||
.*.androiddir | |||
.*.androidstamp | |||
Makefile | |||
Makefile.in | |||
aclocal.m4 | |||
build/autotools/m4/libtool.m4 | |||
build/autotools/m4/ltoptions.m4 | |||
build/autotools/m4/ltsugar.m4 | |||
build/autotools/m4/ltversion.m4 | |||
build/autotools/m4/lt~obsolete.m4 | |||
autom4te.cache | |||
config.h.in | |||
config.h | |||
config.log | |||
config.status | |||
configure | |||
libtool | |||
stamp-* | |||
*-stamp | |||
lolengine-*.tar.* | |||
test-suite.log | |||
# Personal stuff | |||
patch-*.diff | |||
# Debugging cruft | |||
core | |||
!core/ | |||
core.* | |||
vgcore.* | |||
callgrind.out.* | |||
perf.data* | |||
*.gcda | |||
*.gcno | |||
# Editor cruft | |||
.*.swp | |||
*~ | |||
.ycm_extra_conf.pyc | |||
# Visual Studio cruft | |||
.vs | |||
*.vcxproj.user | |||
*.csproj.user | |||
binaries/*Debug | |||
binaries/*Release | |||
build/*.VC.VC.opendb | |||
build/*.VC.db | |||
build/*.sdf | |||
build/*.suo | |||
build/*.opensdf | |||
build/visualstudio/ipch | |||
build/visualstudio/*.log | |||
build/visualstudio/*.XGD | |||
# Emscripten cruft | |||
a.out* | |||
doc/samples/*.html | |||
doc/samples/*.wasm | |||
doc/samples/*.wasm.* | |||
doc/samples/*.js | |||
doc/samples/*/*.html | |||
doc/samples/*/*.wasm | |||
doc/samples/*/*.wasm.* | |||
doc/samples/*/*.js | |||
doc/tutorial/*.html | |||
doc/tutorial/*.wasm | |||
doc/tutorial/*.wasm.* | |||
doc/tutorial/*.js | |||
src/t/*.html | |||
src/t/*.wasm | |||
src/t/*.wasm.* | |||
src/t/*.js | |||
# ReSharper cruft | |||
_ReSharper.* | |||
# Do not exclude anything in external. There is no way to do this recursively | |||
# but the nesting below is currently one level more than our current max. | |||
!external/* | |||
!external/*/* | |||
!external/*/*/* | |||
!external/*/*/*/* | |||
!external/*/*/*/*/* | |||
!external/*/*/*/*/*/* | |||
!external/*/*/*/*/*/*/* | |||
# Our private repositories | |||
src/private | |||
# Our binaries | |||
demos/lol.js/lol.js | |||
doc/samples/benchsuite | |||
doc/samples/bluenoise | |||
doc/samples/btphystest | |||
doc/samples/sandbox/sample | |||
doc/samples/math/pi | |||
doc/samples/math/poly | |||
doc/samples/simplex | |||
doc/tutorial/01_triangle | |||
doc/tutorial/02_cube | |||
doc/tutorial/03_noise | |||
doc/tutorial/04_texture | |||
doc/tutorial/05_easymesh | |||
doc/tutorial/06_sprite | |||
doc/tutorial/07_input | |||
doc/tutorial/08_fbo | |||
doc/tutorial/09_sound | |||
doc/tutorial/11_fractal | |||
doc/tutorial/12_voronoi | |||
doc/tutorial/13_shader_builder | |||
doc/tutorial/14_lua | |||
doc/tutorial/15_gui | |||
doc/tutorial/16_movie | |||
doc/tutorial/16_movie.gif | |||
tools/make-font | |||
# Our data | |||
doc/doxygen.cfg | |||
doc/doxygen.log | |||
doc/html | |||
doc/latex | |||
doc/man | |||
# Our test suites | |||
build/check-*.log | |||
build/check-*.trs | |||
src/t/test-base | |||
src/t/test-math | |||
src/t/test-sys | |||
src/t/test-image | |||
src/t/test-entity | |||
src/t/test-*.log | |||
src/t/test-*.trs | |||
# Our tools | |||
tools/vslol/bin/*/* | |||
tools/vslol/obj/*/* | |||
tools/vslol/obj/*/*/* | |||
tools/vslol/obj/*/*/* | |||
tools/vslol/*.suo | |||
# ImGui cruft | |||
imgui.ini | |||
# Built stuff | |||
binaries/ |
@@ -1,27 +1,8 @@ | |||
[submodule "external"] | |||
path = external | |||
url = ../../lolengine/ext-binaries.git | |||
branch = master | |||
[submodule "imgui"] | |||
path = src/3rdparty/imgui | |||
url = ../../lolengine/ext-imgui.git | |||
branch = master | |||
[submodule "bullet3"] | |||
path = src/3rdparty/bullet3 | |||
url = ../../lolengine/ext-bullet3.git | |||
branch = lol | |||
[submodule "lua"] | |||
path = src/3rdparty/lua | |||
url = ../../lolengine/ext-lua.git | |||
branch = lol | |||
[submodule "pegtl"] | |||
path = src/3rdparty/pegtl | |||
path = include/lol/3rdparty/pegtl | |||
url = ../../lolengine/ext-pegtl.git | |||
branch = lol | |||
[submodule "mingw-std-threads"] | |||
path = src/3rdparty/mingw-std-threads | |||
path = include/lol/3rdparty/mingw-std-threads | |||
url = ../../lolengine/ext-mingw-std-threads.git | |||
branch = master | |||
[submodule "cpp-httplib"] | |||
path = src/3rdparty/cpp-httplib | |||
url = ../../lolengine/ext-cpp-httplib.git |
@@ -1,35 +0,0 @@ | |||
sudo: required | |||
dist: trusty | |||
language: c++ | |||
env: VERBOSE=1 | |||
addons: | |||
apt: | |||
packages: | |||
- build-essential | |||
- automake | |||
- autoconf | |||
- libtool | |||
- pkg-config | |||
- libsdl2-dev | |||
- libsdl2-image-dev | |||
- libsdl2-mixer-dev | |||
- libglew-dev | |||
# this can fix clang compilation | |||
- clang-3.8 | |||
- libc++-dev | |||
before_install: | |||
# - .travis/before_install.sh | |||
- if [ "$CC" = "clang" ]; then export CC="clang-3.8"; fi | |||
- if [ "$CXX" = "clang++" ]; then export CXX="clang++-3.8 -stdlib=libc++"; fi | |||
- ./bootstrap | |||
os: | |||
- linux | |||
# - osx | |||
compiler: | |||
- gcc | |||
- clang | |||
@@ -1,28 +0,0 @@ | |||
{ | |||
"configurations": [ | |||
{ | |||
"name": "Mac", | |||
"includePath": ["/usr/include"], | |||
"browse" : { | |||
"limitSymbolsToIncludedHeaders" : true, | |||
"databaseFilename" : "" | |||
} | |||
}, | |||
{ | |||
"name": "Linux", | |||
"includePath": ["/usr/include"], | |||
"browse" : { | |||
"limitSymbolsToIncludedHeaders" : true, | |||
"databaseFilename" : "" | |||
} | |||
}, | |||
{ | |||
"name": "Win32", | |||
"includePath": ["c:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/include", "src"], | |||
"browse" : { | |||
"limitSymbolsToIncludedHeaders" : true, | |||
"databaseFilename" : "" | |||
} | |||
} | |||
] | |||
} |
@@ -1,37 +0,0 @@ | |||
# The following line might come handy in ~/.vimrc: | |||
# let g:ycm_extra_conf_globlist = ['~/lol/*','!~/*'] | |||
import os | |||
import ycm_core | |||
flags = [ | |||
'-xc++', | |||
'-std=c++11', | |||
# Engine includes | |||
'-I.', | |||
'-I..', | |||
'-Isrc', | |||
# System includes | |||
'-I/usr/include/SDL2', | |||
'-I/usr/include/GL', | |||
'-I/usr/include/libdrm', | |||
'-I/usr/include/libpng15', | |||
# Macros | |||
'-DHAVE_CONFIG_H', | |||
'-D_REENTRANT', | |||
] | |||
def FlagsForFile(filename, **kwargs): | |||
extension = os.path.splitext(filename)[1] | |||
if extension not in [ '.c', '.cpp', '.h' ]: | |||
return None | |||
final_flags = flags | |||
return { | |||
'flags': final_flags, | |||
'do_cache': True | |||
} | |||
@@ -1,16 +0,0 @@ | |||
include $(top_srcdir)/build/autotools/common.am | |||
# Put "people" at the end because they're more likely to break builds. | |||
SUBDIRS = build src tools doc | |||
DIST_SUBDIRS = $(SUBDIRS) binaries | |||
EXTRA_DIST += bootstrap COPYING TODO \ | |||
.gitignore .gitattributes .gitmodules \ | |||
.travis.yml lol.sln build.config | |||
AUTOMAKE_OPTIONS = dist-bzip2 | |||
ACLOCAL_AMFLAGS = -I build/autotools/m4 | |||
test: lolcheck | |||
check: lolcheck | |||
@@ -1,13 +1,4 @@ | |||
# About | |||
A collection of scripts and C++ code to make games, demos and tools. | |||
## Notes | |||
### Nintendo Switch support | |||
That code is private, it needs to be activated manually: | |||
> `git clone https://github.com/samhocevar/lol-nx.git src/private/nx` | |||
The header-only part of the Lol Engine framework. |
@@ -1,38 +0,0 @@ | |||
Large projects | |||
---------------- | |||
- Scripting support. | |||
- Lua is supported, check if CPP -> LUA ticking/updating is supported | |||
- Lua needs more than one-shot-script | |||
- Lua classes may still be a little bit obfuscated, a class renaming/revamping may be needed | |||
- Tiler and Forge are almost the same, try to refactor them. | |||
Engine classes | |||
---------------- | |||
Scene: | |||
- Remove uses of g_scene | |||
- Maybe make Camera a world object instead? | |||
Image: | |||
- Handle pitch in SDL codec (and all others, actually) | |||
- Fix the Floyd-Steinberg code in pixels.cpp | |||
- Add gamma handling in pixels.cpp | |||
- Port remaining libpipi files from src/image/todo/: | |||
Thread: | |||
- Solidify "Threaded-update" objects support | |||
- AsyncImageLoader: "File modified update" is supported by OS, it should use that instead of doing it by hand | |||
- Thread usage may still be a little bit awkward | |||
Debug: | |||
- Add history support. And layer-like sub-section ? (with imGUI support ?) | |||
- ::DrawSetup* is fricking awkward, even I (Touky) get confused by it | |||
Shaders: | |||
- Creation/Setup is still a bit complicated, should look into making it more readable (compatibility with lua ?) | |||
Frame Buffer Object: | |||
- They were working at some point , check if it's still the case, but are still very awkward to use | |||
@@ -0,0 +1,71 @@ | |||
## `lol` headers to keep | |||
src/lol/base/map.h (map utilities) | |||
src/lol/base/types.h (vec_t shortcuts eg. vec2, ivec2, u8vec3 etc.) | |||
src/lol/math/bigint.h | |||
src/lol/math/constants.h | |||
src/lol/math/functions.h | |||
src/lol/math/half.h (needs half.cpp) | |||
src/lol/math/matrix.h | |||
src/lol/math/noise/* | |||
src/lol/math/ops.h | |||
src/lol/math/polynomial.h | |||
src/lol/math/rand.h | |||
src/lol/math/real.h (needs real.cpp) | |||
src/lol/math/transform.h (needs matrix.cpp and transform.cpp) | |||
src/lol/math/vector.h (needs vector.cpp) | |||
src/lol/sys/thread.h | |||
src/lol/sys/timer.h | |||
## other headers to keep | |||
tools/lolunit/lolunit.h | |||
## headers we could clean up and keep | |||
src/lol/algorithm/aabb_tree.h | |||
src/lol/base/assert.h (could be useful) | |||
src/lol/base/avl_tree.h | |||
src/lol/base/string.h (string utilities) | |||
src/lol/image/color.h | |||
src/lol/image/pixel.h (but is it useful?) | |||
src/lol/math/arraynd.h (but do we really want to keep it?) | |||
src/lol/math/geometry.h | |||
src/lol/math/interp.h (but what is it?) | |||
src/numeric.h | |||
## headers to keep in the engine | |||
src/lol/algorithm/portal.h | |||
src/lol/audio/* | |||
src/lol/base/features.h (a bit dangerous to ship) | |||
src/lol/base/log.h | |||
src/lol/debug/* | |||
src/lol/engine.h | |||
src/lol/engine/* | |||
src/lol/engine-internal.h | |||
src/lol/extras.h | |||
src/lol/gpu/* | |||
src/lol/image/image.h | |||
src/lol/image/movie.h | |||
src/lol/image/resource.h | |||
src/lol/legacy.h | |||
src/lol/lua.h | |||
src/lol/net/http.h | |||
src/lol/public.h | |||
src/lol/sys/file.h | |||
src/lol/sys/getopt.h | |||
src/lol/sys/init.h | |||
## headers to remove one day | |||
src/lol/algorithm/sort.h (there’s plenty of stuff in libc++) | |||
src/lol/base/array.h (use std::vector) | |||
src/lol/base/enum.h (can’t see the point) | |||
src/lol/base/tuple.h (use std::tuple) | |||
@@ -1,3 +0,0 @@ | |||
# Everything in this directory is temporary. | |||
@@ -1,136 +0,0 @@ | |||
#! /bin/sh | |||
# bootstrap: generic bootstrap/autogen.sh script for autotools projects | |||
# | |||
# Copyright (c) 2002-2010 Sam Hocevar <sam@hocevar.net> | |||
# | |||
# This program is free software. It comes without any warranty, to | |||
# the extent permitted by applicable law. You can redistribute it | |||
# and/or modify it under the terms of the Do What The Fuck You Want | |||
# To Public License, Version 2, as published by Sam Hocevar. See | |||
# http://www.wtfpl.net/ for more details. | |||
# | |||
# The latest version of this script can be found at the following place: | |||
# http://caca.zoy.org/wiki/build | |||
# Die if an error occurs | |||
set -e | |||
# Guess whether we are using configure.ac or configure.in | |||
if test -f configure.ac; then | |||
conffile="configure.ac" | |||
elif test -f configure.in; then | |||
conffile="configure.in" | |||
else | |||
echo "$0: could not find configure.ac or configure.in" | |||
exit 1 | |||
fi | |||
# Check for needed features | |||
auxdir="`sed -ne 's/^[ \t]*A._CONFIG_AUX_DIR *([[ ]*\([^] )]*\).*/\1/p' $conffile`" | |||
pkgconfig="`grep '^[ \t]*PKG_PROG_PKG_CONFIG' $conffile >/dev/null 2>&1 && echo yes || echo no`" | |||
libtool="`grep '^[ \t]*A._PROG_LIBTOOL' $conffile >/dev/null 2>&1 && echo yes || echo no`" | |||
makefile="`[ -f Makefile.am ] && echo yes || echo no`" | |||
aclocalflags="`sed -ne 's/^[ \t]*ACLOCAL_AMFLAGS[ \t]*=//p' Makefile.am 2>/dev/null || :`" | |||
# Check for automake | |||
amvers="no" | |||
for v in "" "-1.15" "-1.14" "-1.13" "-1.12" "-1.11"; do | |||
if automake${v} --version > /dev/null 2>&1; then | |||
amvers=${v} | |||
break | |||
fi | |||
done | |||
if test "$amvers" = "no"; then | |||
echo "$0: automake not found" | |||
exit 1 | |||
fi | |||
# Check for autoconf | |||
acvers="no" | |||
for v in "" "259" "253"; do | |||
if autoconf${v} --version >/dev/null 2>&1; then | |||
acvers="${v}" | |||
break | |||
fi | |||
done | |||
if test "$acvers" = "no"; then | |||
echo "$0: autoconf not found" | |||
exit 1 | |||
fi | |||
# Check for libtool | |||
if test "$libtool" = "yes"; then | |||
libtoolize="no" | |||
if glibtoolize --version >/dev/null 2>&1; then | |||
libtoolize="glibtoolize" | |||
else | |||
for v in "16" "15" "" "14"; do | |||
if libtoolize${v} --version >/dev/null 2>&1; then | |||
libtoolize="libtoolize${v}" | |||
break | |||
fi | |||
done | |||
fi | |||
if test "$libtoolize" = "no"; then | |||
echo "$0: libtool not found" | |||
exit 1 | |||
fi | |||
fi | |||
# Check for pkg-config | |||
if test "$pkgconfig" = "yes"; then | |||
if ! pkg-config --version >/dev/null 2>&1; then | |||
echo "$0: pkg-config not found" | |||
exit 1 | |||
fi | |||
fi | |||
# Remove old cruft | |||
for x in aclocal.m4 configure config.guess config.log config.sub config.cache config.h.in config.h compile libtool.m4 ltoptions.m4 ltsugar.m4 ltversion.m4 ltmain.sh libtool ltconfig missing mkinstalldirs depcomp install-sh; do rm -f $x autotools/$x; if test -n "$auxdir"; then rm -f "$auxdir/$x"; fi; done | |||
rm -Rf autom4te.cache | |||
if test -n "$auxdir"; then | |||
if test ! -d "$auxdir"; then | |||
mkdir "$auxdir" | |||
fi | |||
aclocalflags="-I $auxdir -I . ${aclocalflags}" | |||
fi | |||
# Honour M4PATH because sometimes M4 doesn't | |||
save_IFS=$IFS | |||
IFS=: | |||
tmp="$M4PATH" | |||
for x in $tmp; do | |||
if test -n "$x"; then | |||
aclocalflags="-I $x ${aclocalflags}" | |||
fi | |||
done | |||
IFS=$save_IFS | |||
# Explain what we are doing from now | |||
set -x | |||
# Bootstrap package | |||
if test "$libtool" = "yes"; then | |||
${libtoolize} --copy --force | |||
if test -n "$auxdir" -a ! "$auxdir" = "." -a -f "ltmain.sh"; then | |||
echo "$0: working around a minor libtool issue" | |||
mv ltmain.sh "$auxdir/" | |||
fi | |||
fi | |||
aclocal${amvers} ${aclocalflags} | |||
autoconf${acvers} | |||
autoheader${acvers} | |||
if test "$makefile" = "yes"; then | |||
#add --include-deps if you want to bootstrap with any other compiler than gcc | |||
#automake${amvers} --add-missing --copy --include-deps | |||
automake${amvers} --foreign --add-missing --copy | |||
fi | |||
# Remove cruft that we no longer want | |||
rm -Rf autom4te.cache | |||
@@ -1,15 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<PropertyGroup Label="Configuration"> | |||
<!-- yes/no values --> | |||
<enable_bullet>yes</enable_bullet> | |||
<enable_ffmpeg>yes</enable_ffmpeg> | |||
<enable_gl>yes</enable_gl> | |||
<enable_sdl>yes</enable_sdl> | |||
<enable_imlib2>yes</enable_imlib2> | |||
<!-- not available yet --> | |||
<enable_png>no</enable_png> | |||
</PropertyGroup> | |||
</Project> |
@@ -1,21 +0,0 @@ | |||
include $(top_srcdir)/build/autotools/common.am | |||
# FIXME: can't include "Lol (vs2015).sln" because of the spaces | |||
EXTRA_DIST += lol-build \ | |||
check-source.sh run-bitten.sh \ | |||
build-linux build-mingw build-mingw64 \ | |||
build-android build-html \ | |||
\ | |||
msbuild/lolfx.targets \ | |||
msbuild/lolfx.xml \ | |||
msbuild/lolfx.props \ | |||
msbuild/lol.config.props \ | |||
msbuild/lol.vars.props \ | |||
msbuild/lol.rules.props \ | |||
\ | |||
autotools/common.am | |||
TESTS = check-source.sh | |||
@@ -1,22 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<manifest xmlns:android="http://schemas.android.com/apk/res/android" | |||
package="net.lolengine.lol_@PROGRAM@" | |||
android:versionCode="1" | |||
android:versionName="1.0"> | |||
<application android:label="@string/app_name" | |||
android:icon="@drawable/icon"> | |||
<activity android:name="net.lolengine.LolActivity" | |||
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" | |||
android:screenOrientation="landscape" | |||
android:label="@string/app_name" | |||
android:launchMode="singleTask"> | |||
<meta-data android:name="android.app.lib_name" | |||
android:value="@PROGRAM@" /> | |||
<intent-filter> | |||
<action android:name="android.intent.action.MAIN" /> | |||
<category android:name="android.intent.category.LAUNCHER" /> | |||
</intent-filter> | |||
</activity> | |||
</application> | |||
<uses-sdk android:minSdkVersion="13" /> | |||
</manifest> |
@@ -1,68 +0,0 @@ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net> | |||
// This program is free software; you can redistribute it and/or | |||
// modify it under the terms of the Do What The Fuck You Want To | |||
// Public License, Version 2, as published by Sam Hocevar. See | |||
// http://www.wtfpl.net/ for more details. | |||
// | |||
package net.lolengine; | |||
import android.app.NativeActivity; /* NativeActivity */ | |||
import android.os.Bundle; /* Bundle */ | |||
import android.content.res.AssetManager; /* getAssets() */ | |||
import android.graphics.Bitmap; | |||
import android.graphics.BitmapFactory; | |||
public class LolActivity extends NativeActivity | |||
{ | |||
static | |||
{ | |||
/* Need to preload libstlport_shared.so somewhere; also need to | |||
* preload lib@PROGRAM@.so otherwise nativeInit() can’t be found. */ | |||
System.loadLibrary("stlport_shared"); | |||
System.loadLibrary("@PROGRAM@"); | |||
} | |||
@Override | |||
protected void onCreate(Bundle saved_instance) | |||
{ | |||
super.onCreate(saved_instance); | |||
m_assets = getAssets(); | |||
} | |||
private AssetManager m_assets; | |||
/* | |||
* Bitmap loading helpers | |||
*/ | |||
public Bitmap openImage(String name) | |||
{ | |||
try | |||
{ | |||
return BitmapFactory.decodeStream(m_assets.open(name)); | |||
} | |||
catch (Exception e) { } | |||
return null; | |||
} | |||
public int getWidth(Bitmap bmp) { return bmp.getWidth(); } | |||
public int getHeight(Bitmap bmp) { return bmp.getHeight(); } | |||
public void getPixels(Bitmap bmp, int[] pixels) | |||
{ | |||
int w = bmp.getWidth(); | |||
int h = bmp.getHeight(); | |||
bmp.getPixels(pixels, 0, w, 0, 0, w, h); | |||
} | |||
public void closeImage(Bitmap bmp) | |||
{ | |||
bmp.recycle(); | |||
} | |||
} | |||
@@ -1,4 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<resources> | |||
<string name="app_name">@PROGRAM@</string> | |||
</resources> |
@@ -1,124 +0,0 @@ | |||
# -*- coding: utf-8 -*- | |||
# vi:syntax=python | |||
# | |||
# Define these variables from the beginning | |||
# | |||
CLEANFILES = | |||
SUFFIXES = | |||
EXTRA_DIST = | |||
NULL = | |||
# | |||
# Miscellaneous rules | |||
# | |||
lol_recursive_rule = \ | |||
@if test -n "$(SUBDIRS)"; then for subdir in $(SUBDIRS); do \ | |||
if test "$$subdir" != "."; then \ | |||
($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $(patsubst %-recursive, %, $@)) || exit 1; \ | |||
fi; done; fi | |||
bench: bench-recursive | |||
bench-recursive: | |||
$(lol_recursive_rule) | |||
lolcheck: lolcheck-recursive | |||
lolcheck-recursive: | |||
$(lol_recursive_rule) | |||
# | |||
# Make tests verbose | |||
# FIXME: this does not seem to work as documented | |||
# | |||
AM_TESTS_FD_REDIRECT = 9>&2 | |||
# | |||
# .lolfx build rule | |||
# | |||
lolfx_gen = $(lolfx_gen_$(V)) | |||
lolfx_gen_ = $(lolfx_gen_$(AM_DEFAULT_VERBOSITY)) | |||
lolfx_gen_0 = @echo " LOLFX " $@; | |||
SUFFIXES += .lolfx | |||
.lolfx.o: | |||
$(lolfx_gen) | |||
$(AM_V_at)(echo "char const *"; \ | |||
echo "lolfx_resource_$(basename $(filter %.lolfx, $^))" | $(SED) 's/[^a-zA-Z0-9_]/_/g'; \ | |||
echo "="; \ | |||
$(SED) 's/"/\\"/g' $(filter %.lolfx, $^) | $(SED) 's/\([^\r]*\).*/"\1\\n"/'; \ | |||
echo ";") \ | |||
> $@.lolfx.cpp && \ | |||
$(CXXCOMPILE) -xc++ -c $@.lolfx.cpp -o $@ && \ | |||
exit=0 || exit=1; rm -f $@.lolfx.cpp ; exit "$$exit" | |||
# Disable on the fly compilation because emscripten doesn't support it | |||
# | $(CXXCOMPILE) -xc++ -c - -o $@ | |||
# | |||
# Win32 rules | |||
# | |||
# This is here in case we forget to make clean after a Windows build | |||
CLEANFILES += $(PROGRAMS:%$(EXEEXT)=%.exe) \ | |||
$(noinst_PROGRAMS:%$(EXEEXT)=%.exe) | |||
# | |||
# Emscripten rules | |||
# | |||
CLEANFILES += $(PROGRAMS:%$(EXEEXT)=%.data) \ | |||
$(noinst_PROGRAMS:%$(EXEEXT)=%.data) | |||
# | |||
# Android rules | |||
# | |||
all-local: all-local-android | |||
clean-local: clean-local-android | |||
if LOL_USE_ANDROID | |||
all-local-android: $(foreach p, $(PROGRAMS:%$(EXEEXT)=%), .$(p).androidstamp) | |||
.%.androidstamp: %$(EXEEXT) | |||
$(eval p := $(^:%$(EXEEXT)=%)) | |||
$(eval d := .$(p).androiddir) | |||
rm -rf "$(d)" | |||
$(MKDIR_P) "$(d)" $(sort $(foreach f, $($(p)_DATA), "$(d)/assets/$(dir $(f))")) | |||
$(foreach f, $($(p)_DATA), $(LN_S) "$(abs_srcdir)/$(f)" "$(d)/assets/$(f)" &&) true | |||
$(SED) -e 's,@PROGRAM@,$(subst -,_,$(p)),' "$(lol_srcdir)/build/android/AndroidManifest.xml" > "$(d)/AndroidManifest.xml" | |||
$(MKDIR_P) "$(d)/src/net/lolengine" | |||
$(SED) -e 's,@PROGRAM@,$(subst -,_,$(p)),' "$(lol_srcdir)/build/android/LolActivity.java" > "$(d)/src/net/lolengine/LolActivity.java" | |||
$(MKDIR_P) "$(d)/res/values" | |||
$(SED) -e 's,@PROGRAM@,$(subst -,_,$(p)),' "$(lol_srcdir)/build/android/strings.xml" > "$(d)/res/values/strings.xml" | |||
$(MKDIR_P) "$(d)/res/drawable" | |||
cp "$(lol_srcdir)/build/android/icon.png" "$(d)/res/drawable/" | |||
$(MKDIR_P) "$(d)/libs/armeabi" | |||
$(LN_S) "$(abs_builddir)/$(p)$(EXEEXT)" "$(d)/libs/armeabi/lib$(p).so" | |||
android update project -t android-19 -n "$(p)" -p "$(d)" | |||
ant debug -f "$(d)/build.xml" | |||
touch $@ | |||
else | |||
all-local-android: | |||
endif | |||
clean-local-android: | |||
$(foreach p, $(PROGRAMS:%$(EXEEXT)=%), rm -rf ".$(p).androiddir";) | |||
$(foreach p, $(PROGRAMS:%$(EXEEXT)=%), rm -f ".$(p).androidstamp";) | |||
# | |||
# Additional rules | |||
# | |||
EXTRA_DIST += $(foreach p, $(PROGRAMS), $($(p)_DATA)) | |||
.PHONY: bench lolcheck | |||
@@ -1,287 +0,0 @@ | |||
dnl | |||
dnl Lol Engine | |||
dnl | |||
dnl Copyright © 2010—2020 Sam Hocevar <sam@hocevar.net> | |||
dnl | |||
dnl Lol Engine is free software. It comes without any warranty, to | |||
dnl the extent permitted by applicable law. You can redistribute it | |||
dnl and/or modify it under the terms of the Do What the Fuck You Want | |||
dnl to Public License, Version 2, as published by the WTFPL Task Force. | |||
dnl See http://www.wtfpl.net/ for more details. | |||
dnl | |||
# LOL_AC_INIT() | |||
# --------------------- | |||
AC_DEFUN([LOL_AC_INIT], [ | |||
dnl Silent rules by default | |||
AM_SILENT_RULES([yes]) | |||
dnl C++11 and later mode. Checked early so that we don't run into surprises. | |||
version_flag='' | |||
LOL_TRY_CXXFLAGS(-std=c++0x, [version_flag='-std=c++0x']) | |||
LOL_TRY_CXXFLAGS(-std=c++11, [version_flag='-std=c++11']) | |||
LOL_TRY_CXXFLAGS(-std=c++14, [version_flag='-std=c++14']) | |||
LOL_TRY_CXXFLAGS(-std=c++17, [version_flag='-std=c++17']) | |||
AM_CXXFLAGS="${AM_CXXFLAGS} ${version_flag}" | |||
CXXFLAGS="${CXXFLAGS} ${version_flag}" | |||
AC_LANG_PUSH(C++) | |||
AC_MSG_CHECKING(for C++11 enum class support) | |||
AC_TRY_LINK([], [enum class Foo : int { Bar, Baz };], | |||
[AC_MSG_RESULT(yes)], | |||
[AC_MSG_RESULT(no) | |||
AC_MSG_ERROR([[C++ compiler does not support C++11 enum classes]])]) | |||
AC_LANG_POP(C++) | |||
]) # LOL_AC_INIT | |||
# LOL_AC_CHECK() | |||
# --------------------- | |||
AC_DEFUN([LOL_AC_CHECK], [ | |||
dnl Check that the C++ compiler really works | |||
AC_LANG_PUSH(C++) | |||
AC_MSG_CHECKING(for a fully working C++ compiler) | |||
AC_TRY_LINK([], [], | |||
[AC_MSG_RESULT(yes)], | |||
[AC_MSG_RESULT(no) | |||
AC_MSG_ERROR([[C++ compiler cannot link executables]])]) | |||
AC_LANG_POP(C++) | |||
AC_C_CONST | |||
AC_C_INLINE | |||
dnl | |||
dnl Common libraries | |||
dnl | |||
AC_CHECK_LIB(m, sin, LIBS="${LIBS} -lm") | |||
AC_CHECK_LIB(pthread, main, LIBS="${LIBS} -lpthread") | |||
dnl | |||
dnl Activate some header-only libraries | |||
dnl | |||
LOL_CFLAGS="$LOL_CFLAGS -I\$(lol_srcdir)/src/3rdparty/cpp-httplib" | |||
LOL_CFLAGS="$LOL_CFLAGS -I\$(lol_srcdir)/src/3rdparty/pegtl/include" | |||
LOL_CFLAGS="$LOL_CFLAGS -I\$(lol_srcdir)/src/3rdparty/imgui" | |||
dnl Use system-provided getopt_long? | |||
ac_cv_have_getopt_long="no" | |||
AC_CHECK_HEADERS(getopt.h unistd.h) | |||
AC_CHECK_FUNCS(getopt_long, | |||
[ac_cv_have_getopt_long="yes"], | |||
[AC_CHECK_LIB(gnugetopt, getopt_long, | |||
[ac_cv_have_getopt_long="yes" | |||
LIBS="${LIBS} -lgnugetopt"])]) | |||
if test "$ac_cv_have_getopt_long" != "no"; then | |||
AC_DEFINE(HAVE_GETOPT_LONG, 1, Define to 1 if you have the ‘getopt_long’ function.) | |||
fi | |||
dnl Use OpenSSL? | |||
ac_cv_have_openssl=no | |||
AC_CHECK_LIB(ssl, OPENSSL_init_ssl, | |||
[ac_cv_have_openssl=yes | |||
AC_DEFINE(LOL_USE_OPENSSL, 1, Define to 1 to use OpenSSL) | |||
LOL_LIBS="${LOL_LIBS} -lssl -lcrypto"]) | |||
AM_CONDITIONAL(LOL_USE_OPENSSL, test "${ac_cv_have_openssl}" = "yes") | |||
dnl Use Bullet Physics? | |||
ac_cv_my_have_bullet="no" | |||
if test "${enable_bullet}" != "no"; then | |||
PKG_CHECK_MODULES(BULLET, bullet, [ac_cv_my_have_bullet="yes"], [:]) | |||
if test "${ac_cv_my_have_bullet}" != "no"; then | |||
AC_DEFINE(LOL_USE_BULLET, 1, Define to 1 to use Bullet Physics) | |||
LOL_CFLAGS="${LOL_CFLAGS} ${BULLET_CFLAGS}" | |||
LOL_LIBS="${LOL_LIBS} ${BULLET_LIBS}" | |||
fi | |||
fi | |||
AM_CONDITIONAL(LOL_USE_BULLET, test "${ac_cv_my_have_bullet}" = "yes") | |||
dnl Use Android? FIXME: super hacks! | |||
ac_cv_my_have_android="no" | |||
AC_CHECK_LIB(log, __android_log_vprint, | |||
[ac_cv_my_have_android="yes" | |||
LOL_LIBS="${LOL_LIBS} -llog -landroid -module -lEGL -lGLESv2"]) | |||
AM_CONDITIONAL(LOL_USE_ANDROID, test "${ac_cv_my_have_android}" != "no") | |||
dnl Use EGL? (autodetect unless GL is disabled) | |||
ac_cv_my_have_egl="no" | |||
if test "${enable_gl}" != "no"; then | |||
PKG_CHECK_MODULES(EGL, egl, [ac_cv_my_have_egl="yes"], [:]) | |||
if test "${ac_cv_my_have_egl}" != "no"; then | |||
AC_DEFINE(LOL_USE_EGL, 1, Define to 1 to use libegl) | |||
EGL_LIBS="${EGL_LIBS} -lX11" | |||
fi | |||
AC_CHECK_HEADERS(EGL/egl.h, | |||
[AC_CHECK_LIB(EGL, eglInitialize, | |||
[ac_cv_my_have_egl="yes" | |||
AC_DEFINE(LOL_USE_EGL, 1, Define to 1 to use libegl) | |||
EGL_LIBS="-lEGL"]) | |||
dnl Raspberry Pi is different, check for it with extra libs; also we | |||
dnl look for a different function to bypass autoconf caching | |||
AC_CHECK_LIB(EGL, eglGetDisplay, | |||
[ac_cv_my_have_egl="yes" | |||
AC_DEFINE(LOL_USE_EGL, 1, Define to 1 to use libegl) | |||
EGL_LIBS="-lEGL -lvcos -lvchiq_arm -lbcm_host -lGLESv2"], | |||
[:], | |||
[-lvcos -lvchiq_arm -lbcm_host -lGLESv2])]) | |||
fi | |||
AM_CONDITIONAL(LOL_USE_EGL, test "${ac_cv_my_have_egl}" != "no") | |||
dnl Use libpng? (replacement for SDL_image) | |||
ac_cv_my_have_libpng="no" | |||
if test "${enable_png}" != "no"; then | |||
PKG_CHECK_MODULES(LIBPNG, libpng, [ac_cv_my_have_libpng="yes"], [:]) | |||
if test "${ac_cv_my_have_libpng}" != "no"; then | |||
AC_DEFINE(LOL_USE_LIBPNG, 1, Define to 1 to use libpng) | |||
fi | |||
fi | |||
AM_CONDITIONAL(LOL_USE_LIBPNG, test "${ac_cv_my_have_libpng}" != "no") | |||
dnl Use Imlib2? | |||
ac_cv_my_have_imlib2="no" | |||
if test "${enable_imlib2}" != "no"; then | |||
PKG_CHECK_MODULES(IMLIB2, imlib2, [ac_cv_my_have_imlib2="yes"], [:]) | |||
if test "${ac_cv_my_have_imlib2}" != "no"; then | |||
AC_DEFINE(LOL_USE_IMLIB2, 1, Define to 1 to use Imlib2) | |||
LOL_CFLAGS="${LOL_CFLAGS} ${IMLIB2_CFLAGS}" | |||
LOL_LIBS="${LOL_LIBS} ${IMLIB2_LIBS}" | |||
fi | |||
fi | |||
AM_CONDITIONAL(LOL_USE_IMLIB2, test "${ac_cv_my_have_imlib2}" = "yes") | |||
dnl Use Windows GDI+? | |||
ac_cv_my_have_gdiplus="no" | |||
AC_LANG_PUSH(C++) | |||
AC_CHECK_HEADERS(gdiplus.h, | |||
[ac_cv_my_have_gdiplus="yes" | |||
LOL_LIBS="${LOL_LIBS} -lgdiplus"], | |||
[ac_cv_my_have_gdiplus="no"], | |||
[#include <algorithm> | |||
using std::min; | |||
using std::max; | |||
#include <windows.h>]) | |||
AC_LANG_POP(C++) | |||
if test "${ac_cv_my_have_gdiplus}" != "no"; then | |||
AC_DEFINE(LOL_USE_GDIPLUS, 1, Define to 1 to use GDI+) | |||
fi | |||
AM_CONDITIONAL(LOL_USE_GDIPLUS, test "${ac_cv_my_have_gdiplus}" = "yes") | |||
dnl Are we building using MinGW? | |||
LOL_TRY_CXXFLAGS(-mwindows -mwin32, | |||
[AM_CXXFLAGS="${AM_CXXFLAGS} -mwindows -mwin32" | |||
LOL_CFLAGS="${LOL_CFLAGS} -I\$(lol_srcdir)/src/3rdparty/mingw-std-threads" | |||
LOL_CFLAGS="${LOL_CFLAGS} -D__STDC_FORMAT_MACROS" | |||
LOL_LIBS="${LOL_LIBS} -uWinMain -u_WinMain@16"]) | |||
dnl Are we building using Emscripten? | |||
ac_cv_my_have_emscripten="no" | |||
AC_CHECK_HEADERS(emscripten.h, | |||
[ac_cv_my_have_emscripten="yes" | |||
AC_CHECK_HEADERS(emscripten/html5.h) | |||
dnl XXX: activate this if memory heap is too small | |||
#AM_CXXFLAGS="${AM_CXXFLAGS} -s ALLOW_MEMORY_GROWTH=1" | |||
dnl See https://github.com/emscripten-core/emscripten/pull/7977 for more details | |||
CPPFLAGS="${CPPFLAGS} -s DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1" | |||
dnl HACK: until emcc properly adds these to EMSDK_OPTS | |||
CPPFLAGS="${CPPFLAGS} -U__i386__ -U__x86_64__ -U__i386 -U__x86_64 -Ui386 -Ux86_64" | |||
CPPFLAGS="${CPPFLAGS} -U__SSE__ -U__SSE2__ -U__MMX__ -UX87_DOUBLE_ROUNDING" | |||
CPPFLAGS="${CPPFLAGS} -UHAVE_GCC_ASM_FOR_X87 -U__STRICT_ANSI__ -U__CYGWIN__"]) | |||
AM_CONDITIONAL(LOL_USE_EMSCRIPTEN, test "${ac_cv_my_have_emscripten}" != "no") | |||
dnl Are we on an OS X or iOS platform? | |||
LOL_TRY_LDFLAGS(-framework Foundation, | |||
[LOL_LIBS="${LOL_LIBS} -framework Foundation"]) | |||
LOL_TRY_LDFLAGS(-framework CoreGraphics, | |||
[LOL_LIBS="${LOL_LIBS} -framework CoreGraphics"]) | |||
LOL_TRY_LDFLAGS(-framework CoreData, | |||
[LOL_LIBS="${LOL_LIBS} -framework CoreData"]) | |||
LOL_TRY_LDFLAGS(-framework UIKit, | |||
[LOL_LIBS="${LOL_LIBS} -framework UIKit"]) | |||
dnl Other complex checks | |||
LOL_AC_CHECK_OPENGL() | |||
LOL_AC_CHECK_SDL() | |||
LOL_AC_CHECK_FFMPEG() | |||
dnl Debug symbols | |||
dnl We use --export-dynamic instead of -rdynamic because the latter causes | |||
dnl emscripten to emit wasm even when html is asked… | |||
LOL_TRY_LDFLAGS(--export-dynamic, [AM_LDFLAGS="${AM_LDFLAGS} --export-dynamic"]) | |||
dnl Code qui fait des warnings == code de porc == deux baffes dans ta gueule | |||
LOL_TRY_CXXFLAGS(-Wall, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wall"]) | |||
LOL_TRY_CXXFLAGS(-Wextra, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wextra"]) | |||
LOL_TRY_CXXFLAGS(-Wpointer-arith, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wpointer-arith"]) | |||
LOL_TRY_CXXFLAGS(-Wcast-align, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wcast-align"]) | |||
LOL_TRY_CXXFLAGS(-Wcast-qual, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wcast-qual"]) | |||
LOL_TRY_CXXFLAGS(-Wshadow, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wshadow"]) | |||
LOL_TRY_CXXFLAGS(-Wsign-compare, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wsign-compare"]) | |||
LOL_TRY_CXXFLAGS(-Wstrict-overflow=1, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wstrict-overflow=1"]) | |||
dnl Add these even though they're implicitly set, so that we can safely | |||
dnl remove them from within a Makefile. | |||
LOL_TRY_CXXFLAGS(-Wuninitialized, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wuninitialized"]) | |||
LOL_TRY_CXXFLAGS(-Wnarrowing, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wnarrowing"]) | |||
LOL_TRY_CXXFLAGS(-Wunused, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wunused"]) | |||
LOL_TRY_CXXFLAGS(-Wcast-align, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wcast-align"]) | |||
LOL_TRY_CXXFLAGS(-Wunused-parameter, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wunused-parameter"]) | |||
LOL_TRY_CXXFLAGS(-Wstrict-aliasing, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wstrict-aliasing"]) | |||
LOL_TRY_CXXFLAGS(-Wparentheses, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wparentheses"]) | |||
LOL_TRY_CXXFLAGS(-Wreorder, [AM_CXXFLAGS="${AM_CXXFLAGS} -Wreorder"]) | |||
dnl Disable these warnings because they're annoyingly verbose | |||
LOL_TRY_CXXFLAGS(-Wno-psabi, [AM_CPPFLAGS="${AM_CPPFLAGS} -Wno-psabi"]) | |||
]) # LOL_AC_CHECK | |||
# LOL_AC_FINI() | |||
# --------------------- | |||
AC_DEFUN([LOL_AC_FINI], [ | |||
dnl How to use the Lol Engine outside this tree | |||
LOL_CFLAGS="$LOL_CFLAGS $SDL_CFLAGS $GL_CFLAGS $EGL_CFLAGS $LIBPNG_CFLAGS" | |||
LOL_LIBS="$LOL_LIBS $SDL_LIBS $GL_LIBS $EGL_LIBS $LIBPNG_LIBS $D3D_LIBS" | |||
LOL_DEPS="${LOL_DEPS} \$(lol_builddir)/src/liblol-core.a" | |||
LOL_LUA_DEPS="${LOL_LUA_DEPS} \$(lol_builddir)/src/3rdparty/liblol-lua.a" | |||
dnl How to use the Lol Engine inside this tree | |||
AM_CPPFLAGS="${AM_CPPFLAGS} -I\$(lol_srcdir)/src" | |||
AM_CPPFLAGS="${AM_CPPFLAGS} -DLOL_CONFIG_SOURCESUBDIR=\\\"\$(subdir)\\\"" | |||
AM_CPPFLAGS="${AM_CPPFLAGS} ${LOL_CFLAGS}" | |||
AM_LDFLAGS="${AM_LDFLAGS} ${LOL_DEPS}" | |||
AM_LDFLAGS="${AM_LDFLAGS} ${LOL_LIBS}" | |||
dnl Extra flags | |||
AC_SUBST(LOL_CFLAGS) | |||
AC_SUBST(LOL_LIBS) | |||
AC_SUBST(LOL_DEPS) | |||
AC_SUBST(LOL_LUA_DEPS) | |||
AC_SUBST(AM_CFLAGS) | |||
AC_SUBST(AM_CPPFLAGS) | |||
AC_SUBST(AM_CXXFLAGS) | |||
AC_SUBST(AM_LDFLAGS) | |||
]) # LOL_AC_FINI | |||
@@ -1,63 +0,0 @@ | |||
dnl | |||
dnl Lol Engine | |||
dnl | |||
dnl Copyright © 2010—2017 Sam Hocevar <sam@hocevar.net> | |||
dnl | |||
dnl Lol Engine is free software. It comes without any warranty, to | |||
dnl the extent permitted by applicable law. You can redistribute it | |||
dnl and/or modify it under the terms of the Do What the Fuck You Want | |||
dnl to Public License, Version 2, as published by the WTFPL Task Force. | |||
dnl See http://www.wtfpl.net/ for more details. | |||
dnl | |||
# LOL_AC_CHECK_FFMPEG() | |||
# --------------------- | |||
AC_DEFUN([LOL_AC_CHECK_FFMPEG], | |||
[ | |||
ac_cv_my_have_ffmpeg="no" | |||
if test "${enable_ffmpeg}" != "no"; then | |||
LOL_AC_CHECK_FFMPEG_INNER() | |||
fi | |||
AM_CONDITIONAL(LOL_USE_FFMPEG, test "${ac_cv_my_have_ffmpeg}" != "no") | |||
]) | |||
# LOL_AC_CHECK_FFMPEG_INNER() | |||
# --------------------------- | |||
AC_DEFUN([LOL_AC_CHECK_FFMPEG_INNER], | |||
[ | |||
ac_cv_my_have_ffmpeg="yes" | |||
PKG_CHECK_MODULES([LIBAVCODEC], [libavcodec], [:], [ac_cv_my_have_ffmpeg=no]) | |||
PKG_CHECK_MODULES([LIBAVUTIL], [libavutil], [:], [ac_cv_my_have_ffmpeg=no]) | |||
PKG_CHECK_MODULES([LIBAVFORMAT], [libavformat], [:], [ac_cv_my_have_ffmpeg=no]) | |||
PKG_CHECK_MODULES([LIBSWSCALE], [libswscale], [:], [ac_cv_my_have_ffmpeg=no]) | |||
LOL_FFMPEG_EXTRA_LIBS="" | |||
if test "${ac_cv_my_have_ffmpeg}" != "yes"; then | |||
ac_cv_my_have_ffmpeg="yes" | |||
AC_CHECK_HEADERS(libavcodec/avcodec.h, [:], [ac_cv_my_have_ffmpeg=no]) | |||
AC_CHECK_HEADERS(libavformat/avformat.h, [:], [ac_cv_my_have_ffmpeg=no]) | |||
AC_CHECK_HEADERS(libswscale/swscale.h, [:], [ac_cv_my_have_ffmpeg=no]) | |||
if test "${ac_cv_my_have_ffmpeg}" = "yes"; then | |||
LIBAVCODEC_LIBS="-lavcodec" | |||
LIBAVUTIL_LIBS="-lavutil" | |||
LIBAVFORMAT_LIBS="-lavformat" | |||
LIBSWSCALE_LIBS="-lswscale" | |||
LIBSWRESAMPLE_LIBS="-lswresample" | |||
dnl Required by avformat/network.c | |||
AC_CHECK_LIB(ws2_32, main, LOL_FFMPEG_EXTRA_LIBS="${LOL_FFMPEG_EXTRA_LIBS} -lws2_32") | |||
dnl Required by avformat/tls_schannel.c | |||
AC_CHECK_LIB(secur32, main, LOL_FFMPEG_EXTRA_LIBS="${LOL_FFMPEG_EXTRA_LIBS} -lsecur32") | |||
dnl Required by avutil/random_seed.c | |||
AC_CHECK_LIB(bcrypt, main, LOL_FFMPEG_EXTRA_LIBS="${LOL_FFMPEG_EXTRA_LIBS} -lbcrypt") | |||
dnl Required by avcodec/dxva2.c | |||
AC_CHECK_LIB(ole32, main, LOL_FFMPEG_EXTRA_LIBS="${LOL_FFMPEG_EXTRA_LIBS} -lole32") | |||
fi | |||
fi | |||
if test "${ac_cv_my_have_ffmpeg}" = "yes"; then | |||
AC_DEFINE(LOL_USE_FFMPEG, 1, Define to 1 to use FFmpeg) | |||
LOL_CFLAGS="${LOL_CFLAGS} ${LIBAVFORMAT_CFLAGS} ${LIBAVUTIL_CFLAGS} ${LIBAVCODEC_CFLAGS} ${LIBSWSCALE_CFLAGS}" | |||
LOL_LIBS="${LOL_LIBS} ${LIBAVFORMAT_LIBS} ${LIBAVCODEC_LIBS} ${LIBAVUTIL_LIBS} ${LIBSWSCALE_LIBS} ${LIBSWRESAMPLE_LIBS} ${LOL_FFMPEG_EXTRA_LIBS}" | |||
fi | |||
]) # LOL_AC_CHECK_FFMPEG_INNER | |||
@@ -1,156 +0,0 @@ | |||
dnl | |||
dnl Lol Engine | |||
dnl | |||
dnl Copyright © 2010—2017 Sam Hocevar <sam@hocevar.net> | |||
dnl | |||
dnl Lol Engine is free software. It comes without any warranty, to | |||
dnl the extent permitted by applicable law. You can redistribute it | |||
dnl and/or modify it under the terms of the Do What the Fuck You Want | |||
dnl to Public License, Version 2, as published by the WTFPL Task Force. | |||
dnl See http://www.wtfpl.net/ for more details. | |||
dnl | |||
# LOL_AC_CHECK_OPENGL() | |||
# --------------------- | |||
AC_DEFUN([LOL_AC_CHECK_OPENGL], | |||
[ | |||
ac_cv_my_have_gl="no" | |||
ac_cv_my_have_glew="no" | |||
if test "${enable_gl}" != "no"; then | |||
LOL_AC_CHECK_OPENGL_INNER() | |||
fi | |||
AM_CONDITIONAL(LOL_USE_GL, test "${ac_cv_my_have_gl}" != "no") | |||
AM_CONDITIONAL(LOL_USE_GLEW, test "${ac_cv_my_have_glew}" != "no") | |||
]) | |||
# LOL_AC_CHECK_OPENGL_INNER() | |||
# --------------------------- | |||
AC_DEFUN([LOL_AC_CHECK_OPENGL_INNER], | |||
[ | |||
dnl Find which version of OpenGL to use | |||
ac_cv_my_have_gl="no" | |||
ac_cv_my_stop_looking_for_gl="no" | |||
if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then | |||
LIBS_save="$LIBS" | |||
LIBS="$LIBS -Wl,-framework -Wl,OpenGL" | |||
AC_MSG_CHECKING(for -framework OpenGL) | |||
AC_TRY_LINK([], [], | |||
[AC_MSG_RESULT(yes) | |||
ac_cv_my_have_gl="yes" | |||
GL_LIBS="${GL_LIBS} -framework OpenGL" | |||
LOL_TRY_CXXFLAGS(-ObjC++, [CXXFLAGS="${CXXFLAGS} -ObjC++"]) | |||
AC_DEFINE(HAVE_GL_2X, 1, Define to 1 if GL 2.x is available)], | |||
[AC_MSG_RESULT(no)]) | |||
LIBS="$LIBS_save" | |||
fi | |||
if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then | |||
LIBS_save="$LIBS" | |||
LIBS="$LIBS -Wl,-framework -Wl,OpenGLES" | |||
AC_MSG_CHECKING(for -framework OpenGLES) | |||
AC_TRY_LINK([], [], | |||
[AC_MSG_RESULT(yes) | |||
ac_cv_my_have_gl="yes" | |||
GL_LIBS="${GL_LIBS} -framework OpenGLES" | |||
LOL_TRY_CXXFLAGS(-ObjC++, [CXXFLAGS="${CXXFLAGS} -ObjC++"]) | |||
AC_DEFINE(HAVE_GLES_2X, 1, Define to 1 if GLES 2.x is available)], | |||
[AC_MSG_RESULT(no)]) | |||
LIBS="$LIBS_save" | |||
fi | |||
dnl Use the Raspberry Pi libraries? | |||
if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then | |||
AC_CHECK_HEADERS(bcm_host.h, | |||
[AC_CHECK_LIB(vcos, main, | |||
[ac_cv_my_have_gl="yes" | |||
ac_cv_my_stop_looking_for_gl="yes" | |||
AC_DEFINE(HAVE_GLES_2X, 1, Define to 1 if GLES 2.x is available) | |||
dnl FIXME: -lEGL does not belong here but the configure test fails | |||
dnl when cross-compiling, so we add it manually here. | |||
GL_LIBS="${GL_LIBS} -lGLESv2 -lEGL -lvcos -lvchiq_arm -lbcm_host"])]) | |||
fi | |||
if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then | |||
PKG_CHECK_MODULES(GLES2, glesv2, | |||
[ac_cv_my_have_gl="yes" | |||
AC_DEFINE(HAVE_GLES_2X, 1, Define to 1 if GLES 2.x is available) | |||
GL_CFLAGS="${GL_CFLAGS} ${GLES2_CFLAGS}" | |||
GL_LIBS="${GL_LIBS} ${GLES2_LIBS}"], | |||
[:]) | |||
fi | |||
if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then | |||
AC_CHECK_HEADER(GLES2/gl2.h, | |||
[ac_cv_my_have_gl="yes" | |||
AC_DEFINE(HAVE_GLES_2X, 1, Define to 1 if GLES 2.x is available) | |||
AC_CHECK_LIB(GLESv2, glEnable, | |||
[GL_LIBS="${GL_LIBS} -lGLESv2"])]) | |||
fi | |||
if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then | |||
PKG_CHECK_MODULES(GL, gl, | |||
[ac_cv_my_have_gl="yes" | |||
AC_DEFINE(HAVE_GL_2X, 1, Define to 1 if GL 2.x is available)], | |||
[:]) | |||
fi | |||
if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then | |||
AC_CHECK_LIB(GL, glEnable, | |||
[ac_cv_my_have_gl="yes" | |||
AC_DEFINE(HAVE_GL_2X, 1, Define to 1 if GL 2.x is available) # FIXME: hackish | |||
GL_LIBS="-lGL"]) | |||
fi | |||
if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then | |||
AC_CHECK_HEADER(GL/gl.h, | |||
[LIBS_save="$LIBS" | |||
LIBS="$LIBS -lopengl32" | |||
AC_MSG_CHECKING(for glLoadIdentity in -lopengl32) | |||
AC_TRY_LINK([#include <GL/gl.h>], | |||
[glLoadIdentity();], | |||
[ac_cv_my_have_gl="yes" | |||
AC_DEFINE(HAVE_GL_2X, 1, Define to 1 if GL 2.x is available) # FIXME: hack | |||
AC_MSG_RESULT(yes) | |||
GL_LIBS="-lopengl32"], | |||
[AC_MSG_RESULT(no)]) | |||
LIBS="$LIBS_save"]) | |||
fi | |||
dnl Use Glew? | |||
PKG_CHECK_MODULES(GLEW, glew, | |||
[ac_cv_my_have_glew="yes" | |||
GL_CFLAGS="${GLEW_CFLAGS} ${GL_CFLAGS}" | |||
GL_LIBS="${GLEW_LIBS} ${GL_LIBS}"], | |||
[:]) | |||
AC_CHECK_HEADER(GL/glew.h, | |||
[LIBS_save="${LIBS}" | |||
LIBS="${LIBS} -lglew32s ${GL_LIBS}" | |||
AC_MSG_CHECKING(for glewInit in -lglew32s) | |||
AC_TRY_LINK( | |||
[#include <GL/glew.h>], | |||
[glewInit();], | |||
[ac_cv_my_have_glew="yes" | |||
GL_LIBS="-lglew32s ${GL_LIBS}" | |||
AC_MSG_RESULT(yes)], | |||
[AC_MSG_RESULT(no)]) | |||
LIBS="${LIBS_save}"]) | |||
if test "${ac_cv_my_have_glew}" != "no"; then | |||
AC_DEFINE(HAVE_GLES_2X, 1, Define to 1 if GLES 2.x is available) | |||
AC_DEFINE(LOL_USE_GLEW, 1, Define to 1 to use libglew) | |||
fi | |||
dnl Poor man's GL feature detection if all else failed. | |||
save_LIBS="${LIBS}" | |||
LIBS="${LIBS} ${GL_LIBS} ${GLES2_LIBS}" | |||
AC_CHECK_FUNCS(glBegin) | |||
LIBS="${save_LIBS}" | |||
dnl Warn if we couldn't find an OpenGL-like API | |||
if test "${ac_cv_my_have_gl}" = "no"; then | |||
AC_MSG_WARN([[No OpenGL or OpenGL ES implementation found]]) | |||
fi | |||
]) # LOL_AC_CHECK_OPENGL_INNER | |||
@@ -1,59 +0,0 @@ | |||
dnl | |||
dnl Lol Engine | |||
dnl | |||
dnl Copyright © 2010—2016 Sam Hocevar <sam@hocevar.net> | |||
dnl | |||
dnl Lol Engine is free software. It comes without any warranty, to | |||
dnl the extent permitted by applicable law. You can redistribute it | |||
dnl and/or modify it under the terms of the Do What the Fuck You Want | |||
dnl to Public License, Version 2, as published by the WTFPL Task Force. | |||
dnl See http://www.wtfpl.net/ for more details. | |||
dnl | |||
dnl LOL_TRY_CFLAGS (CFLAGS, [ACTION-IF-WORKS], [ACTION-IF-FAILS]) | |||
dnl check if $CC supports a given set of cflags | |||
AC_DEFUN([LOL_TRY_CFLAGS], | |||
[AC_MSG_CHECKING([if $CC supports $1 flags]) | |||
save_CFLAGS="$CFLAGS" | |||
CFLAGS="$1 -Werror" | |||
AC_TRY_COMPILE([],[],[ac_cv_try_cflags_ok=yes],[ac_cv_try_cflags_ok=no]) | |||
CFLAGS="$save_CFLAGS" | |||
AC_MSG_RESULT([$ac_cv_try_cflags_ok]) | |||
if test x"$ac_cv_try_cflags_ok" = x"yes"; then | |||
ifelse([$2],[],[:],[$2]) | |||
else | |||
ifelse([$3],[],[:],[$3]) | |||
fi]) | |||
dnl LOL_TRY_CXXFLAGS (CXXFLAGS, [ACTION-IF-WORKS], [ACTION-IF-FAILS]) | |||
dnl check if $CXX supports a given set of cxxflags | |||
AC_DEFUN([LOL_TRY_CXXFLAGS], | |||
[AC_MSG_CHECKING([if $CXX supports $1 flags]) | |||
AC_LANG_PUSH(C++) | |||
save_CXXFLAGS="$CXXFLAGS" | |||
CXXFLAGS="$1 -Werror" | |||
AC_TRY_COMPILE([],[],[ac_cv_try_cxxflags_ok=yes],[ac_cv_try_cxxflags_ok=no]) | |||
CXXFLAGS="$save_CXXFLAGS" | |||
AC_MSG_RESULT([$ac_cv_try_cxxflags_ok]) | |||
if test x"$ac_cv_try_cxxflags_ok" = x"yes"; then | |||
ifelse([$2],[],[:],[$2]) | |||
else | |||
ifelse([$3],[],[:],[$3]) | |||
fi | |||
AC_LANG_POP(C++)]) | |||
dnl LOL_TRY_LDFLAGS (LDFLAGS, [ACTION-IF-WORKS], [ACTION-IF-FAILS]) | |||
dnl check if $CC supports a given set of ldflags | |||
AC_DEFUN([LOL_TRY_LDFLAGS], | |||
[AC_MSG_CHECKING([if $CC supports $1 flags]) | |||
save_LDFLAGS="$LDFLAGS" | |||
LDFLAGS="$1 -Werror" | |||
AC_TRY_LINK([],[],[ac_cv_try_ldflags_ok=yes],[ac_cv_try_ldflags_ok=no]) | |||
LDFLAGS="$save_LDFLAGS" | |||
AC_MSG_RESULT([$ac_cv_try_ldflags_ok]) | |||
if test x"$ac_cv_try_ldflags_ok" = x"yes"; then | |||
ifelse([$2],[],[:],[$2]) | |||
else | |||
ifelse([$3],[],[:],[$3]) | |||
fi]) |
@@ -1,126 +0,0 @@ | |||
dnl | |||
dnl Lol Engine | |||
dnl | |||
dnl Copyright © 2010—2017 Sam Hocevar <sam@hocevar.net> | |||
dnl | |||
dnl Lol Engine is free software. It comes without any warranty, to | |||
dnl the extent permitted by applicable law. You can redistribute it | |||
dnl and/or modify it under the terms of the Do What the Fuck You Want | |||
dnl to Public License, Version 2, as published by the WTFPL Task Force. | |||
dnl See http://www.wtfpl.net/ for more details. | |||
dnl | |||
# LOL_AC_CHECK_SDL() | |||
# ------------------ | |||
AC_DEFUN([LOL_AC_CHECK_SDL], | |||
[ | |||
ac_cv_my_have_sdl="no" | |||
ac_cv_my_have_sdl_image="no" | |||
ac_cv_my_have_sdl_mixer="no" | |||
if test "${enable_sdl}" != "no"; then | |||
LOL_AC_CHECK_SDL_INNER() | |||
fi | |||
AM_CONDITIONAL(LOL_USE_SDL, test "${ac_cv_my_have_sdl}" != "no") | |||
AM_CONDITIONAL(LOL_USE_SDL_MIXER, test "${ac_cv_my_have_sdl_mixer}" != "no") | |||
AM_CONDITIONAL(LOL_USE_SDL_IMAGE, test "${ac_cv_my_have_sdl_image}" != "no") | |||
]) | |||
# LOL_AC_CHECK_SDL_INNER() | |||
# ------------------------ | |||
AC_DEFUN([LOL_AC_CHECK_SDL_INNER], | |||
[ | |||
dnl Find which version of SDL to use (always required on Linux or Win32) | |||
dnl | |||
dnl Defined C/C++ macros: | |||
dnl LOL_USE_SDL -- whether SDL v2 was found | |||
dnl LOL_USE_SDL_IMAGE -- whether SDL_image was found | |||
dnl LOL_USE_SDL_MIXER -- whether SDL_mixer was found | |||
dnl HAVE_SDL_H -- whether to include <SDL.h> | |||
dnl HAVE_SDL2_SDL_H -- whether to include <SDL2/SDL.h> | |||
dnl Generated automake conditionals: | |||
dnl LOL_USE_SDL -- whether SDL v2 was found | |||
dnl LOL_USE_SDL_IMAGE -- whether SDL_image was found | |||
dnl LOL_USE_SDL_MIXER -- whether SDL_mixer was found | |||
dnl Generated shell variables: | |||
dnl SDL_CFLAGS -- flags for SDL compilation | |||
dnl SDL_LIBS -- flags for SDL linking | |||
dnl First, try the proper pkg-config check for SDL2 | |||
if test "x${ac_cv_my_have_sdl}" = xno; then | |||
PKG_CHECK_MODULES(SDL2, sdl2, | |||
[ac_cv_my_have_sdl="yes" | |||
PKG_CHECK_MODULES(SDL2MIXER, SDL2_mixer, | |||
[ac_cv_my_have_sdl_mixer="yes" | |||
AC_DEFINE(HAVE_SDL_MIXER_H, 1, Define to 1 to use SDL_mixer.h)], | |||
[:]) | |||
PKG_CHECK_MODULES(SDL2IMAGE, SDL2_image, | |||
[ac_cv_my_have_sdl_image="yes" | |||
AC_DEFINE(HAVE_SDL_IMAGE_H, 1, Define to 1 to use SDL_image.h)], | |||
[:]) | |||
SDL_CFLAGS="${SDL2_CFLAGS} ${SDL2MIXER_CFLAGS} ${SDL2IMAGE_CFLAGS}" | |||
SDL_LIBS="${SDL2_LIBS} ${SDL2MIXER_LIBS} ${SDL2IMAGE_LIBS}" | |||
AC_DEFINE(HAVE_SDL_H, 1, Define to 1 to use SDL.h)], | |||
[:]) | |||
fi | |||
dnl Maybe all this has failed, try direct inclusion instead | |||
if test "x${ac_cv_my_have_sdl}" = xno; then | |||
save_CPPFLAGS="${CPPFLAGS}" | |||
save_LIBS="${LIBS}" | |||
CPPFLAGS="${CPPFLAGS} ${SDL_CFLAGS}" | |||
LIBS="${LIBS} ${SDL_LIBS}" | |||
AC_CHECK_HEADERS(SDL.h SDL2/SDL.h, | |||
[ac_cv_my_have_sdl="yes"]) | |||
if test "x${ac_cv_my_have_sdl}" != xno; then | |||
AC_CHECK_HEADERS(SDL_mixer.h SDL2/SDL_mixer.h, | |||
[ac_cv_my_have_sdl_mixer="yes"]) | |||
AC_CHECK_HEADERS(SDL_image.h SDL2/SDL_image.h, | |||
[ac_cv_my_have_sdl_image="yes"]) | |||
AC_CHECK_LIB(SDL2, main, | |||
[SDL_LIBS="${SDL_LIBS} -lSDL2"], | |||
[ac_cv_my_have_sdl="no"]) | |||
AC_CHECK_LIB(SDL2main, main, | |||
[SDL_LIBS="${SDL_LIBS} -lSDL2main -lSDL2"]) | |||
AC_CHECK_LIB(SDL2_mixer, main, | |||
[SDLMIXER_LIBS="${SDLMIXER_LIBS} -lSDL2_mixer"], | |||
[ac_cv_my_have_sdl_mixer="no"]) | |||
AC_CHECK_LIB(SDL2_image, main, | |||
[SDLIMAGE_LIBS="${SDLIMAGE_LIBS} -lSDL2_image"], | |||
[AC_CHECK_LIB(SDL2_image_bmp-jpg-png, main, | |||
[SDLIMAGE_LIBS="${SDLIMAGE_LIBS} -lSDL2_image_bmp-jpg-png"], | |||
[ac_cv_my_have_sdl_image="no"])]) | |||
SDL_CFLAGS="${SDL_CFLAGS} ${SDLMIXER_CFLAGS} ${SDLIMAGE_CFLAGS}" | |||
SDL_LIBS="${SDL_LIBS} ${SDLMIXER_LIBS} ${SDLIMAGE_LIBS}" | |||
fi | |||
CPPFLAGS="${save_CPPFLAGS}" | |||
LIBS="${save_LIBS}" | |||
fi | |||
dnl Convert all this into conditionals | |||
if test "x${ac_cv_my_have_sdl}" = xno; then | |||
AC_MSG_WARN([SDL v2 not found]) | |||
else | |||
AC_DEFINE(LOL_USE_SDL, 1, Define to 1 to use SDL) | |||
fi | |||
if test "x${ac_cv_my_have_sdl_mixer}" = xno; then | |||
AC_MSG_WARN([SDL_mixer not found]) | |||
else | |||
AC_DEFINE(LOL_USE_SDL_MIXER, 1, Define to 1 to use SDL_mixer) | |||
fi | |||
if test "x${ac_cv_my_have_sdl_image}" = xno; then | |||
AC_MSG_WARN([SDL_image not found]) | |||
else | |||
AC_DEFINE(LOL_USE_SDL_IMAGE, 1, Define to 1 to use SDL_image) | |||
fi | |||
]) # LOL_AC_CHECK_SDL_INNER | |||
@@ -1,55 +0,0 @@ | |||
dnl | |||
dnl Lol Engine | |||
dnl | |||
dnl Copyright © 2010—2016 Sam Hocevar <sam@hocevar.net> | |||
dnl | |||
dnl Lol Engine is free software. It comes without any warranty, to | |||
dnl the extent permitted by applicable law. You can redistribute it | |||
dnl and/or modify it under the terms of the Do What the Fuck You Want | |||
dnl to Public License, Version 2, as published by the WTFPL Task Force. | |||
dnl See http://www.wtfpl.net/ for more details. | |||
dnl | |||
# LOL_AC_SUBPROJECT() | |||
# --------------------- | |||
AC_DEFUN([LOL_AC_SUBPROJECT], [ | |||
dnl | |||
dnl Parse build.config if present | |||
dnl | |||
AC_MSG_WARN([${srcdir}]) | |||
ac_lol_configure_args="" | |||
if test -f ${srcdir}/build.config; then | |||
for x in `sed -ne 's,.*<enable_\(@<:@^>@:>@*\)>\(@<:@^<@:>@*\)</enable_@<:@^>@:>@*>.*,\1=\2,p' ${srcdir}/build.config`; do | |||
eval "enable_${x}" | |||
case ${x} in | |||
*=no) arg="--disable-${x%=no}" ;; | |||
*=yes) arg="--enable-${x%=yes}" ;; | |||
*) arg="" ;; | |||
esac | |||
ac_lol_configure_args="${ac_lol_configure_args} ${arg}" | |||
done | |||
fi | |||
dnl | |||
dnl Build and configure Lol Engine before our repository | |||
dnl Ensure $lol_srcdir and $lol_builddir are properly set | |||
dnl | |||
ac_configure_args="${ac_configure_args} --enable-subproject ${ac_lol_configure_args} $1" | |||
AC_CONFIG_SUBDIRS([lol]) | |||
AC_SUBST(lol_srcdir, '${top_srcdir}/lol') | |||
AC_SUBST(lol_builddir, '${top_builddir}/lol') | |||
dnl | |||
dnl Subprojects use the same macros as us | |||
dnl | |||
LOL_AC_INIT() | |||
LOL_AC_CHECK() | |||
LOL_AC_FINI() | |||
]) # LOL_AC_SUBPROJECT | |||
@@ -1,22 +0,0 @@ | |||
<build xmlns:sh="http://bitten.edgewall.org/tools/sh" | |||
xmlns:svn="http://bitten.edgewall.org/tools/svn" | |||
xmlns:c="http://bitten.edgewall.org/tools/c"> | |||
<step id="checkout" description="Checkout source from repository"> | |||
<svn:checkout url="svn://svn.zoy.org/lolengine/" path="${path}" revision="${revision}" /> | |||
</step> | |||
<step id="bootstrap" description="Bootstrap build system"> | |||
<sh:exec file="./build/lol-build" args="bootstrap ${platform}"/> | |||
</step> | |||
<step id="configure" description="Configure tree"> | |||
<sh:exec file="./build/lol-build" args="configure ${platform}"/> | |||
</step> | |||
<step id="build" description="Build tree"> | |||
<sh:exec file="./build/lol-build" args="build ${platform}"/> | |||
</step> | |||
<step id="check" description="Run tests"> | |||
<sh:exec file="./build/lol-build" args="check ${platform}"/> | |||
</step> | |||
<step id="clean" description="Clean tree"> | |||
<sh:exec file="./build/lol-build" args="clean ${platform}"/> | |||
</step> | |||
</build> |
@@ -1,22 +0,0 @@ | |||
<build xmlns:sh="http://bitten.edgewall.org/tools/sh" | |||
xmlns:svn="http://bitten.edgewall.org/tools/svn" | |||
xmlns:c="http://bitten.edgewall.org/tools/c"> | |||
<step id="checkout" description="Checkout source from repository"> | |||
<svn:checkout url="svn://svn.zoy.org/lolengine/" path="${path}" revision="${revision}" username="anonymous" password="" no_auth_cache="true" /> | |||
</step> | |||
<step id="bootstrap" description="Bootstrap build system"> | |||
<sh:exec file="./build/lol-build" args="bootstrap ${platform}"/> | |||
</step> | |||
<step id="configure" description="Configure tree"> | |||
<sh:exec file="./build/lol-build" args="configure ${platform}"/> | |||
</step> | |||
<step id="build" description="Build tree"> | |||
<sh:exec file="./build/lol-build" args="build ${platform}"/> | |||
</step> | |||
<step id="check" description="Run tests"> | |||
<sh:exec file="./build/lol-build" args="check ${platform}"/> | |||
</step> | |||
<step id="clean" description="Clean tree"> | |||
<sh:exec file="./build/lol-build" args="clean ${platform}"/> | |||
</step> | |||
</build> |
@@ -1,10 +0,0 @@ | |||
#!/bin/sh | |||
# This can't hurt | |||
make distclean | |||
set -e | |||
./build/lol-build "$@" bootstrap android-arm | |||
./build/lol-build "$@" configure android-arm | |||
./build/lol-build "$@" build android-arm | |||
@@ -1,10 +0,0 @@ | |||
#!/bin/sh | |||
# This can't hurt | |||
make distclean | |||
set -e | |||
"$(dirname "$0")/lol-build" "$@" bootstrap web-html | |||
"$(dirname "$0")/lol-build" "$@" configure web-html | |||
"$(dirname "$0")/lol-build" "$@" build web-html | |||
@@ -1,10 +0,0 @@ | |||
#!/bin/sh | |||
# This can't hurt | |||
make distclean | |||
set -e | |||
./build/lol-build "$@" bootstrap web-js | |||
./build/lol-build "$@" configure web-js | |||
./build/lol-build "$@" build web-js | |||
@@ -1,11 +0,0 @@ | |||
#!/bin/sh | |||
## Native Linux compilation for Lol Engine -- Sam Hocevar <sam@hocevar.net> | |||
set -ex | |||
./bootstrap | |||
./configure | |||
make clean | |||
make -j6 | |||
@@ -1,10 +0,0 @@ | |||
#!/bin/sh | |||
# This can't hurt | |||
make distclean | |||
set -e | |||
./build/lol-build "$@" bootstrap windows-i386 | |||
./build/lol-build "$@" configure windows-i386 | |||
./build/lol-build "$@" build windows-i386 | |||
@@ -1,10 +0,0 @@ | |||
#!/bin/sh | |||
# This can't hurt | |||
make distclean | |||
set -e | |||
./build/lol-build "$@" bootstrap windows-amd64 | |||
./build/lol-build "$@" configure windows-amd64 | |||
./build/lol-build "$@" build windows-amd64 | |||
@@ -1,10 +0,0 @@ | |||
#!/bin/sh | |||
# This can't hurt | |||
make distclean | |||
set -e | |||
./build/lol-build "$@" bootstrap raspi-arm | |||
./build/lol-build "$@" configure raspi-arm | |||
./build/lol-build "$@" build raspi-arm | |||
@@ -1,209 +0,0 @@ | |||
#!/bin/sh | |||
set -e | |||
fix=false | |||
quiet=false | |||
while [ "$#" -gt 0 ]; do | |||
case "$1" in | |||
-q) | |||
quiet=true | |||
;; | |||
-w) | |||
fix=true | |||
;; | |||
-c) | |||
commit=true | |||
fix=true | |||
quiet=true | |||
;; | |||
*) | |||
echo "E: invalid argument $1" >&2 | |||
exit 1 | |||
;; | |||
esac | |||
shift | |||
done | |||
error() { if [ "$quiet" != true ]; then echo "E: $1" >&2; fi } | |||
info() { if [ "$quiet" != true ]; then echo "I: $1" >&2; fi } | |||
# Ensure the system tools do not attempt to perform multibyte conversions | |||
export LANG=C | |||
# Find out where the top directory is and go there | |||
top_srcdir="$(cd "$(dirname $0)"; cd ..; pwd)" | |||
cd "$top_srcdir" | |||
# Check for working tools | |||
if [ "$(echo foo | grep -c foo)" != 1 ]; then | |||
error "grep -c does not appear to work, cancelling" | |||
exit 0 | |||
fi | |||
SED=sed | |||
if gsed --version >/dev/null 2>&1; then | |||
SED=gsed | |||
fi | |||
if [ "$(echo 'x\x' | $SED 's/.*[^x\t]//')" != x ]; then | |||
error "sed does not appear to work, cancelling" | |||
exit 0 | |||
fi | |||
if d2u -h >/dev/null 2>&1; then | |||
d2u=d2u | |||
elif dos2unix -h >/dev/null 2>&1; then | |||
d2u=dos2unix | |||
else | |||
error "d2u or dos2unix not found, cancelling" | |||
exit 0 | |||
fi | |||
# Find out whether we need to care about CRLF | |||
case "$(uname 2>/dev/null)" in | |||
MINGW*|MSYS*) | |||
can_check_crlf=false | |||
;; | |||
*) | |||
can_check_crlf=true | |||
;; | |||
esac | |||
# Find out what kind of Vcs directory this is | |||
if [ -f "$top_srcdir/.git/index" ]; then | |||
info "detected Git repository" | |||
repo=git | |||
else | |||
info "not in a Git directory, nothing to do" | |||
exit 0 | |||
fi | |||
total_crlfs=0 | |||
total_spaces=0 | |||
total_tabs=0 | |||
OIFS="$IFS" | |||
IFS=' | |||
' | |||
FILES="`git ls-files`" | |||
total_files=0 | |||
for file in $FILES; do | |||
if [ -f "$file" ]; then | |||
total_files="$(($total_files + 1))" | |||
fi | |||
done | |||
total_errors=0 | |||
for file in $FILES; do | |||
should_check_crlf=false | |||
should_check_spaces=false | |||
should_check_props=false | |||
case "$file" in | |||
# These files we know how to handle | |||
*.c|*.cpp|*.m|*.mm|*.h|*.hh|*.lolfx|*.lua|*.l|*.y|*.sh|*.py) | |||
should_check_crlf=true | |||
should_check_spaces=true | |||
should_check_props=true | |||
;; | |||
*) | |||
continue | |||
;; | |||
esac | |||
case "$file" in | |||
# Don't harass these people, but fix their line endings | |||
people/peeweek/*|\ | |||
people/touky/*|\ | |||
people/benlitz/*|\ | |||
people/sam/lua-*) | |||
should_check_spaces=false | |||
;; | |||
esac | |||
clean=true | |||
# Check for CR LF | |||
if [ "$can_check_crlf" = true -a "$should_check_crlf" = true ]; then | |||
ncrlfs="$(od -tx1 "$file" | cut -b8- | tr ' ' '\n' | grep -c 0d || true)" | |||
total_crlfs="$(($total_crlfs + $ncrlfs))" | |||
if [ "$ncrlfs" -gt 0 ]; then | |||
clean=false | |||
if [ "$fix" = true ]; then | |||
$d2u -q "$file" | |||
info "$file has $ncrlfs CR characters" | |||
else | |||
error "$file has $ncrlfs CR characters" | |||
fi | |||
fi | |||
fi | |||
# Check for trailing spaces | |||
if [ "$should_check_spaces" = true ]; then | |||
nspaces="$($SED 's/.*[^ \t]//' "$file" | tr -cd '\t ' | wc -c)" | |||
total_spaces="$(($total_spaces + $nspaces))" | |||
if [ "$nspaces" -gt 0 ]; then | |||
clean=false | |||
if [ "$fix" = true ]; then | |||
$SED -i 's/[[:space:]][[:space:]]*$//g' "$file" | |||
info "$file has $nspaces trailing spaces" | |||
else | |||
error "$file has $nspaces trailing spaces" | |||
fi | |||
fi | |||
fi | |||
# Check for tabs | |||
if [ "$should_check_spaces" = true ]; then | |||
ntabs="$(tr -cd '\t' < "$file" | wc -c)" | |||
total_tabs="$(($total_tabs + $ntabs))" | |||
if [ "$ntabs" -gt 0 ]; then | |||
clean=false | |||
if [ "$fix" = true ]; then | |||
$SED -i 's/\t/ /g' "$file" | |||
info "$file has $ntabs tabs" | |||
else | |||
error "$file has $ntabs tabs" | |||
fi | |||
fi | |||
fi | |||
if [ "$clean" != true ]; then | |||
total_errors="$(($total_errors + 1))" | |||
fi | |||
done | |||
IFS="$OIFS" | |||
if [ "$total_errors" -gt 0 ]; then | |||
if [ "$commit" = "true" ]; then | |||
# EITHER: commit all modified files | |||
git commit --author 'Lolbot <lolbot@zoy.org>' -a -F - << EOF | |||
fixed $total_errors files out of $total_files: | |||
- removed $total_crlfs CR characters | |||
- removed $total_spaces trailing whitespaces | |||
- replaced $total_tabs tabs with spaces | |||
EOF | |||
elif [ "$fix" = "true" ]; then | |||
# OR: report in stdout | |||
info "fixed $total_errors files out of $total_files:" | |||
if [ "$total_crlfs" -gt 0 ]; then | |||
info " - fixed $total_crlfs CR characters" | |||
fi | |||
if [ "$total_spaces" -gt 0 ]; then | |||
info " - fixed $total_spaces trailing spaces" | |||
fi | |||
if [ "$total_tabs" -gt 0 ]; then | |||
info " - fixed $total_tabs tabs" | |||
fi | |||
info "re-run with -c to commit fixes" | |||
else | |||
# OR: warn about how to fix errors | |||
info "re-run with -w to fix errors" | |||
exit 1 | |||
fi | |||
else | |||
info "all $total_files source files appear to be OK, congratulations" | |||
fi | |||
@@ -1,344 +0,0 @@ | |||
#!/bin/sh | |||
# | |||
# Lol Engine build script | |||
# Usage: | |||
# lol-build [<flags>...] <action> [<platform>] | |||
# | |||
# Supported flags: | |||
# --enable-debug | |||
# --enable-devel | |||
# --enable-release | |||
# | |||
# Where <action> is one of: | |||
# - bootstrap | |||
# - configure | |||
# - build | |||
# - check | |||
# - clean | |||
# | |||
# And <platform> is one of: | |||
# - linux-i386 | |||
# - linux-amd64 | |||
# - ios-arm | |||
# - osx-amd64 | |||
# - android-arm | |||
# - win*-i386 | |||
# - win*-amd64 | |||
# - raspi-arm | |||
# - web-html | |||
# - web-js | |||
# | |||
set -e | |||
############################################################################### | |||
# Commandline parsing | |||
# | |||
action="" | |||
platform="" | |||
configure_flags="" | |||
while [ "$#" -gt 0 ]; do | |||
case "$1" in | |||
--enable-debug|--enable-devel|--enable-release) | |||
configure_flags="${configure_flags} $1" | |||
;; | |||
--*) | |||
echo "E: invalid flag $1" | |||
exit 1 | |||
;; | |||
*) | |||
if [ -z "$action" ]; then | |||
action="$1" | |||
else | |||
platform="$1" | |||
fi | |||
;; | |||
esac | |||
shift | |||
done | |||
############################################################################### | |||
# Initialisation code | |||
# | |||
# - sets the top_srcdir variable | |||
# - sets the LOL_PARALLEL variable | |||
# - fix PATH and MKPATH if necessary | |||
# | |||
__init__() | |||
{ | |||
top_srcdir="$(dirname "$0")/.." | |||
cd "$top_srcdir" | |||
top_srcdir="`pwd`" | |||
# Try to count CPU cores. First obvious try: /proc/cpuinfo on Linux | |||
case "$cpu_count" in | |||
[1-9]|[1-9][0-9]|[1-9][0-9][0-9]) ;; | |||
*) if [ -r "/proc/cpuinfo" ]; then | |||
cpu_count="$(grep -c '^processor\>' /proc/cpuinfo 2>/dev/null || true)" | |||
fi ;; | |||
esac | |||
# If that didn't work, try sysctl (for OS X machines) | |||
case "$cpu_count" in | |||
[1-9]|[1-9][0-9]|[1-9][0-9][0-9]) ;; | |||
*) cpu_count="$(sysctl -n hw.ncpu 2>/dev/null || true)" ;; | |||
esac | |||
# Otherwise, CPUInfo.exe (from Xoreax's XGE) may help on Windows | |||
case "$cpu_count" in | |||
[1-9]|[1-9][0-9]|[1-9][0-9][0-9]) ;; | |||
*) cpu_count="$(CPUInfo.exe | sed -ne 's/CPU Cores.* \([0-9][0-9]*\)/\1/p')" ;; | |||
esac | |||
# Otherwise, Windows may define NUMBER_OF_PROCESSORS | |||
case "$cpu_count" in | |||
[1-9]|[1-9][0-9]|[1-9][0-9][0-9]) ;; | |||
*) cpu_count="$NUMBER_OF_PROCESSORS" ;; | |||
esac | |||
# Otherwise, be conservative and assume 1 CPU core | |||
case "$cpu_count" in | |||
[1-9]|[1-9][0-9]|[1-9][0-9][0-9]) ;; | |||
*) cpu_count=1 ;; | |||
esac | |||
# Now decide how many parallel threads to launch | |||
case "$cpu_count" in | |||
1) LOL_PARALLEL=1 ;; | |||
2) LOL_PARALLEL=3 ;; | |||
*) LOL_PARALLEL="$(expr $cpu_count '*' 3 / 2)" ;; | |||
esac | |||
case "${MSYSTEM}" in | |||
MINGW32|MINGW64) | |||
PATH="$PATH:./external/gtk-2.22.1/bin" | |||
M4PATH="$M4PATH:./external/gtk-2.22.1/share/aclocal" | |||
;; | |||
esac | |||
# Ensure we don’t launch weird Windows binaries when cross-compiling | |||
WINEDLLOVERRIDES="winemenubuilder.exe,wineboot.exe,explorer.exe,winedbg.exe=d" | |||
export WINEDLLOVERRIDES | |||
# Ensure SDL does not redirect stdout/stderr to local files | |||
SDL_STDIO_REDIRECT=0 | |||
export SDL_STDIO_REDIRECT | |||
} | |||
bootstrap() | |||
{ | |||
cd "$top_srcdir" | |||
case "$platform" in | |||
*) | |||
PATH="$PATH" M4PATH="$M4PATH" ./bootstrap | |||
;; | |||
esac | |||
} | |||
do_configure() | |||
{ | |||
./configure ${configure_flags} "$@" | |||
} | |||
configure() | |||
{ | |||
cd "$top_srcdir" | |||
case "$platform" in | |||
android-arm) | |||
PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$PWD/external/libcaca-0.99.beta18/lib/pkgconfig" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/libcaca-0.99.beta18/lib/arm-linux-androideabi -lz" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/libcaca-0.99.beta18/include -DCACA_STATIC" | |||
;; | |||
win*-i386) | |||
if test "x${MSYSTEM}" = xMINGW32; then | |||
: | |||
elif i586-mingw32msvc-g++ --version >/dev/null 2>&1; then | |||
HOSTFLAGS=--host=i586-mingw32msvc | |||
BUILDFLAGS=--build=none | |||
elif i686-w64-mingw32-g++ --version >/dev/null 2>&1; then | |||
HOSTFLAGS=--host=i686-w64-mingw32 | |||
BUILDFLAGS=--build=none | |||
else | |||
echo "Error: could not find win32 compiler" >&2 | |||
false | |||
fi | |||
if test "x${MSYSTEM}" = xMINGW64; then | |||
# If using mingw64, we're not really cross-compiling | |||
BUILDFLAGS= | |||
fi | |||
PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$PWD/external/gtkglarea-2.0.1/lib/pkgconfig" | |||
PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$PWD/external/libcaca-0.99.beta18/lib/pkgconfig" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/ffmpeg-20190130/lib/i686-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/glew-2.1.0/lib/i686-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/sdl-2.0.9/lib/i686-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/sdl-image-2.0.4/lib/i686-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/sdl-mixer-2.0.4/lib/i686-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/gtk-2.22.1/lib" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/gtk-2.22.1/bin" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/gtkglarea-2.0.1/lib" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/libcaca-0.99.beta18/lib/i686-w64-mingw32" | |||
;; | |||
win*-amd64) | |||
if test "x${MSYSTEM}" = xMINGW64; then | |||
: | |||
elif x86_64-w64-mingw32-g++ --version >/dev/null 2>&1; then | |||
HOSTFLAGS=--host=x86_64-w64-mingw32 | |||
BUILDFLAGS=--build=none | |||
else | |||
echo "Error: could not find win64 compiler" >&2 | |||
false | |||
fi | |||
if test "x${MSYSTEM}" = xMINGW32; then | |||
# If using mingw32, we're not really cross-compiling | |||
BUILDFLAGS= | |||
fi | |||
PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$PWD/external/gtkglarea-2.0.1/lib/pkgconfig" | |||
PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$PWD/external/libcaca-0.99.beta18/lib/pkgconfig" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/ffmpeg-20190130/lib/x86_64-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/glew-2.1.0/lib/x86_64-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/sdl-2.0.9/lib/x86_64-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/sdl-image-2.0.4/lib/x86_64-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/sdl-mixer-2.0.4/lib/x86_64-w64-mingw32" | |||
LDFLAGS="$LDFLAGS -L$PWD/external/libcaca-0.99.beta18/lib/x86_64-w64-mingw32" | |||
;; | |||
*-i386) | |||
# Ensure we're _really_ on i386 | |||
CXXFLAGS="$CXXFLAGS -m32" | |||
;; | |||
*-amd64) | |||
# Ensure we're _really_ on amd64 | |||
CXXFLAGS="$CXXFLAGS -m64" | |||
;; | |||
web-*) | |||
# Force cross-compilation because AC_TRY_LINK is going to check | |||
# whether our binaries have the executable bit set. | |||
HOSTFLAGS=--host=none | |||
BUILDFLAGS=--build=`$top_srcdir/.auto/config.guess` | |||
;; | |||
esac | |||
case "$platform" in | |||
ios-arm) | |||
XCODE="/Applications/Xcode.app/Contents/Developer" | |||
SDKVER="6.1" | |||
DEVROOT="$XCODE/Platforms/iPhoneOS.platform/Developer" | |||
SDKROOT="$DEVROOT/SDKs/iPhoneOS$SDKVER.sdk" | |||
CC="$XCODE/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang" | |||
CXX="$XCODE/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++" | |||
do_configure --host=armv7-apple-darwin10 CPPFLAGS="$CPPFLAGS" LDFLAGS="$LDFLAGS" CC="$CC" CXX="$CXX" | |||
;; | |||
android-arm) | |||
CPPFLAGS="$CPPFLAGS -I$ANDROID_NDK_ROOT/sources/android/native_app_glue -fpic -fomit-frame-pointer -fno-strict-aliasing" | |||
CFLAGS="$CFLAGS" | |||
CXXFLAGS="$CXXFLAGS" | |||
LOL_LIBS="$LOL_LIBS -lm -fpic -XCClinker -shared -u ANativeActivity_onCreate" | |||
HOST=armv7a-linux-androideabi27 | |||
PKG_CONFIG_PATH="$PKG_CONFIG_PATH" do_configure --host="$HOST" CC="$HOST-clang" CXX="$HOST-clang++" ac_cv_exeext=.so CPPFLAGS="$CPPFLAGS" CFLAGS="$CFLAGS" CXXFLAGS="$CXXFLAGS" LDFLAGS="$LDFLAGS" LOL_LIBS="$LOL_LIBS" | |||
# FIXME: is this needed? | |||
# ant debug | |||
# ant debug install | |||
# ant clean | |||
;; | |||
raspi-arm) | |||
do_configure --host=arm-bcm2708hardfp-linux-gnueabi CPPFLAGS="-I$RASPI_SDK_ROOT/firmware/opt/vc/include -I$RASPI_SDK_ROOT/firmware/opt/vc/include/interface/vmcs_host/linux -I$RASPI_SDK_ROOT/chroot/usr/include -I$RASPI_SDK_ROOT/chroot/usr/include/arm-linux-gnueabihf" LDFLAGS="-L$RASPI_SDK_ROOT/firmware/opt/vc/lib -L$RASPI_SDK_ROOT/chroot/lib/arm-linux-gnueabihf -Wl,-rpath-link -Wl,$RASPI_SDK_ROOT/chroot/lib/arm-linux-gnueabihf -L$RASPI_SDK_ROOT/chroot/usr/lib/arm-linux-gnueabihf -Wl,-rpath-link -Wl,$RASPI_SDK_ROOT/chroot/usr/lib/arm-linux-gnueabihf -Wl,--unresolved-symbols=ignore-in-shared-libs" | |||
;; | |||
osx-amd64) | |||
# HACK: use clang++ because of a memory leak in llvm-g++. | |||
do_configure CXX=clang++ CC=clang | |||
;; | |||
win*-i386|win*-amd64) | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/sdl-2.0.9/include" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/sdl-image-2.0.4/include" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/sdl-mixer-2.0.4/include" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/ffmpeg-20190130/include" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/glew-2.1.0/include -DGLEW_STATIC" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtk-2.22.1/lib/glib-2.0/include" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtk-2.22.1/lib/gtk-2.0/include" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtk-2.22.1/include/glib-2.0" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtk-2.22.1/include/gtk-2.0" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtk-2.22.1/include/cairo" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtk-2.22.1/include/pango-1.0" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtk-2.22.1/include/gdk-pixbuf-2.0" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtk-2.22.1/include/atk-1.0" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/gtkglarea-2.0.1/include" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/src/3rdparty/imgui/include" | |||
CPPFLAGS="$CPPFLAGS -mms-bitfields" | |||
LDFLAGS="$LDFLAGS -static-libgcc -static-libstdc++" | |||
GTK_LIBS="$GTK_LIBS -lgtkgl-2.0 -lopengl32 -lglew32 -lgdi32" | |||
GTK_LIBS="$GTK_LIBS -lgtk-win32-2.0 -lgdk-win32-2.0" | |||
GTK_LIBS="$GTK_LIBS -lglib-2.0 -lgthread-2.0 -lgobject-2.0" | |||
CPPFLAGS="$CPPFLAGS -I$PWD/external/libcaca-0.99.beta18/include -DCACA_STATIC" | |||
PATH="$PATH" PKG_CONFIG_PATH="$PKG_CONFIG_PATH" do_configure $HOSTFLAGS $BUILDFLAGS CPPFLAGS="$CPPFLAGS" LDFLAGS="$LDFLAGS" GTK_LIBS="$GTK_LIBS" | |||
;; | |||
web-*) | |||
# First do an emcc run so that dependent libraries are generated | |||
emflags="-s USE_SDL=2 -s USE_SDL_IMAGE=2 -s USE_SDL_MIXER=2" | |||
touch conftest.c ; emcc $(echo $emflags) conftest.c -c -o conftest.o ; rm -f conftest.c conftest.o | |||
# We use --enable-release otherwise builds are really too slow | |||
do_configure --enable-release $HOSTFLAGS $BUILDFLAGS CC=emcc CXX=em++ AR=emar RANLIB=emranlib PKG_CONFIG=/bin/false SDL_CONFIG=/bin/false ac_cv_exeext=".${platform##web-}" CPPFLAGS="$emflags" CXXFLAGS="$emflags" CFLAGS="$emflags" | |||
;; | |||
*) | |||
PATH="$PATH" do_configure CFLAGS="$CXXFLAGS" CXXFLAGS="$CXXFLAGS" | |||
;; | |||
esac | |||
} | |||
build() | |||
{ | |||
cd "$top_srcdir" | |||
case "$platform" in | |||
win*-i386) | |||
# Because of locking issues in Wine’s winepath.exe, we only | |||
# build the static libraries in parallel. | |||
make -j$LOL_PARALLEL -C src/3rdparty liblol-lua.a | |||
make -j$LOL_PARALLEL -C src/ liblol-core.a | |||
make | |||
;; | |||
*) | |||
make -j$LOL_PARALLEL | |||
;; | |||
esac | |||
} | |||
check() | |||
{ | |||
cd "$top_srcdir" | |||
case "$platform" in | |||
ios-arm) | |||
;; | |||
android-arm) | |||
;; | |||
raspi-arm) | |||
;; | |||
web-*) | |||
;; | |||
win*-i386) | |||
# If neither $MSYSTEM or $DISPLAY are set, and xvfb-run | |||
# exists, use it to run the test suite. | |||
if test "x${MSYSTEM}${DISPLAY}" = x \ | |||
&& xvfb-run --help 2>&1 >/dev/null; then | |||
xvfb-run -a make check VERBOSE=1 | |||
else | |||
make check VERBOSE=1 | |||
fi | |||
;; | |||
win*-amd64) | |||
# No support for Wine64 yet | |||
;; | |||
*) | |||
make check VERBOSE=1 | |||
;; | |||
esac | |||
} | |||
clean() | |||
{ | |||
cd "$top_srcdir" | |||
case "$platform" in | |||
*) | |||
make distclean | |||
;; | |||
esac | |||
} | |||
__init__ | |||
echo "lol-build: executing action '$action' on platform '$platform'" >&2 | |||
eval "$action" | |||
@@ -1,10 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<ItemGroup> | |||
<ProjectReference Condition="'$(enable_bullet)'!='no'" Include="$(LolDir)\src\3rdparty\lol-bullet.vcxproj"> | |||
<Project>{83d3b207-c601-4025-8f41-01dedc354661}</Project> | |||
</ProjectReference> | |||
</ItemGroup> | |||
</Project> |
@@ -1,10 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<ItemGroup> | |||
<ProjectReference Include="$(LolDir)\src\lol-core.vcxproj"> | |||
<Project>{9e62f2fe-3408-4eae-8238-fd84238ceeda}</Project> | |||
</ProjectReference> | |||
</ItemGroup> | |||
</Project> |
@@ -1,10 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<ItemGroup> | |||
<ProjectReference Include="$(LolDir)\src\3rdparty\lol-lua.vcxproj"> | |||
<Project>{d84021ca-b233-4e0f-8a52-071b83bbccc4}</Project> | |||
</ProjectReference> | |||
</ItemGroup> | |||
</Project> |
@@ -1,61 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<!-- | |||
- Import settings that can be overridden by the user | |||
--> | |||
<Import Condition="Exists('$(SolutionDir)\lol\build.config')" Project="$(SolutionDir)\lol\build.config" /> | |||
<Import Condition="Exists('$(SolutionDir)\build.config')" Project="$(SolutionDir)\build.config" /> | |||
<!-- | |||
- Import defaults settings from Visual Studio | |||
--> | |||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> | |||
<!-- | |||
- Default settings for Debug configurations | |||
--> | |||
<PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration"> | |||
<UseDebugLibraries>true</UseDebugLibraries> | |||
</PropertyGroup> | |||
<!-- | |||
- Default settings for Release configurations | |||
--> | |||
<PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration"> | |||
<UseDebugLibraries>false</UseDebugLibraries> | |||
<WholeProgramOptimization>true</WholeProgramOptimization> | |||
</PropertyGroup> | |||
<!-- | |||
- Default settings for any configuration | |||
--> | |||
<PropertyGroup Label="Configuration"> | |||
<CharacterSet>MultiByte</CharacterSet> | |||
<UseOfMfc>false</UseOfMfc> | |||
<ExceptionHandling>false</ExceptionHandling> | |||
<FloatingPointModel>Fast</FloatingPointModel> | |||
</PropertyGroup> | |||
<!-- | |||
- Select the platform toolset depending on the platform | |||
--> | |||
<PropertyGroup Condition="'$(Platform)'=='Win32'" Label="Configuration"> | |||
<PlatformToolset>v141</PlatformToolset> | |||
</PropertyGroup> | |||
<PropertyGroup Condition="'$(Platform)'=='x64'" Label="Configuration"> | |||
<PlatformToolset>v141</PlatformToolset> | |||
</PropertyGroup> | |||
<!-- | |||
- Secret stuff for platforms under NDA | |||
--> | |||
<Import Condition="Exists('$(LolDir)\src\private\nx\msbuild\nx.config.props')" | |||
Project="$(LolDir)\src\private\nx\msbuild\nx.config.props" /> | |||
<!-- | |||
- Import final settings from Visual Studio | |||
--> | |||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> | |||
</Project> |
@@ -1,20 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<Import Project="$(LolDir)\build\msbuild\lol.config.props" /> | |||
<ImportGroup Label="ExtensionSettings"> | |||
<Import Project="$(LolDir)\build\msbuild\lolfx.props" /> | |||
</ImportGroup> | |||
<ImportGroup Label="PropertySheets"> | |||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol.vars.props" /> | |||
</ImportGroup> | |||
<PropertyGroup Label="UserMacros" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol.rules.props" /> | |||
<ItemDefinitionGroup /> | |||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> | |||
<ImportGroup Label="ExtensionTargets"> | |||
<Import Project="$(LolDir)\build\msbuild\lolfx.targets" /> | |||
</ImportGroup> | |||
</Project> |
@@ -1,123 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<PropertyGroup> | |||
<LinkIncremental Condition="'$(Configuration)'=='Debug'">true</LinkIncremental> | |||
<LinkIncremental Condition="'$(Configuration)'=='Release'">false</LinkIncremental> | |||
</PropertyGroup> | |||
<!-- | |||
- Secret stuff for platforms under NDA | |||
--> | |||
<Import Condition="Exists('$(LolDir)\src\private\nx\msbuild\nx.rules.props')" | |||
Project="$(LolDir)\src\private\nx\msbuild\nx.rules.props" /> | |||
<ItemDefinitionGroup> | |||
<ClCompile> | |||
<WarningLevel>Level3</WarningLevel> | |||
<!-- Use latest version of the C++ draft --> | |||
<LanguageStandard>stdcpplatest</LanguageStandard> | |||
<!-- Always multiprocessor, never minimal rebuild --> | |||
<MultiProcessorCompilation>true</MultiProcessorCompilation> | |||
<MinimalRebuild>false</MinimalRebuild> | |||
<!-- We should use %(RelativeDir) here but for some reason it's an _absolute_ dir. WTF. --> | |||
<ObjectFileName>$(IntDir)/%(Directory)/</ObjectFileName> | |||
<AdditionalIncludeDirectories> | |||
$(LolDir)\src; | |||
$(LolDir)\src\3rdparty\bullet3\src; | |||
$(LolDir)\tools\lolunit; | |||
$(PegtlIncludes); | |||
$(ImguiIncludes); | |||
$(BtPhysIncludes); | |||
$(GlIncludes); | |||
%(AdditionalIncludeDirectories) | |||
</AdditionalIncludeDirectories> | |||
<AdditionalIncludeDirectories Condition="'$(Platform)'=='Win32' Or '$(Platform)'=='x64'"> | |||
$(SdlIncludes); | |||
$(CppHttpIncludes); | |||
$(FfmpegIncludes); | |||
$(AssimpIncludes); | |||
$(XinputIncludes); | |||
%(AdditionalIncludeDirectories) | |||
</AdditionalIncludeDirectories> | |||
<AdditionalPreprocessorDefinitions> | |||
NOMINMAX; | |||
_CRT_SECURE_NO_WARNINGS; | |||
B3_USE_CLEW; | |||
LUA_ANSI; | |||
</AdditionalPreprocessorDefinitions> | |||
<PreprocessorDefinitions>$(AdditionalPreprocessorDefinitions.Replace('\n',''));%(PreprocessorDefinitions)</PreprocessorDefinitions> | |||
<!-- Trim trailing backslashes and escape them for C++ --> | |||
<PreprocessorDefinitions>LOL_CONFIG_PROJECTDIR="$(ProjectDir.Trim('\').Replace('\','/'))";%(PreprocessorDefinitions)</PreprocessorDefinitions> | |||
<PreprocessorDefinitions>LOL_CONFIG_SOLUTIONDIR="$(SolutionDir.Trim('\').Replace('\','/'))";%(PreprocessorDefinitions)</PreprocessorDefinitions> | |||
<PreprocessorDefinitions Condition="'$(Platform)'=='Win32'">WIN32;$(Win32Defines);%(PreprocessorDefinitions)</PreprocessorDefinitions> | |||
<PreprocessorDefinitions Condition="'$(Platform)'=='x64'">WIN32;$(Win32Defines);%(PreprocessorDefinitions)</PreprocessorDefinitions> | |||
<PreprocessorDefinitions Condition="'$(Platform)'=='Orbis'">$(OrbisDefines);%(PreprocessorDefinitions)</PreprocessorDefinitions> | |||
</ClCompile> | |||
<ClCompile Condition="'$(Configuration)'=='Debug'"> | |||
<GenerateDebugInformation>true</GenerateDebugInformation> | |||
<Optimization>Disabled</Optimization> | |||
<RuntimeLibrary Condition="'$(Platform)'=='Win32' Or '$(Platform)'=='x64'">MultiThreadedDebugDLL</RuntimeLibrary> | |||
<PreprocessorDefinitions>_DEBUG;LOL_BUILD_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> | |||
</ClCompile> | |||
<ClCompile Condition="'$(Configuration)'=='Release'"> | |||
<GenerateDebugInformation>true</GenerateDebugInformation> | |||
<!-- For Microsoft tools --> | |||
<Optimization>MaxSpeed</Optimization> | |||
<!-- For PlayStation tools --> | |||
<OptimizationLevel>Level2</OptimizationLevel> | |||
<RuntimeLibrary Condition="'$(Platform)'=='Win32' Or '$(Platform)'=='x64'">MultiThreadedDLL</RuntimeLibrary> | |||
<FunctionLevelLinking>true</FunctionLevelLinking> | |||
<IntrinsicFunctions>true</IntrinsicFunctions> | |||
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed> | |||
<PreprocessorDefinitions>NDEBUG;LOL_BUILD_RELEASE;%(PreprocessorDefinitions)</PreprocessorDefinitions> | |||
</ClCompile> | |||
<Link Condition="'$(Platform)'=='Win32' Or '$(Platform)'=='x64'"> | |||
<!-- FIXME: not for the static library! --> | |||
<AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;$(SdlDeps);$(FfmpegDeps);$(AssimpDeps);$(LibGccDeps);$(GdiDeps);$(XinputDeps);$(GlDeps);$(CppHttpDeps);%(AdditionalDependencies)</AdditionalDependencies> | |||
<AdditionalLibraryDirectories>$(LibGccLibs);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
<AdditionalLibraryDirectories>$(SdlLibs);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
<AdditionalLibraryDirectories>$(CppHttpLibs);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
<AdditionalLibraryDirectories>$(FfmpegLibs);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
<AdditionalLibraryDirectories>$(AssimpLibs);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
<AdditionalLibraryDirectories>$(GlLibs);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
<AdditionalLibraryDirectories>$(XinputLibs);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
<SubSystem Condition="'$(enable_sdl)'!='no'">Windows</SubSystem> | |||
<SubSystem Condition="'$(enable_sdl)'=='no'">Console</SubSystem> | |||
</Link> | |||
<Link Condition="'$(Platform)'=='Orbis'"> | |||
<AdditionalLibraryDirectories>$(OrbisLibs);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
<AdditionalDependencies>$(OrbisDeps);%(AdditionalDependencies)</AdditionalDependencies> | |||
</Link> | |||
<Link Condition="'$(Configuration)'=='Debug'"> | |||
<GenerateDebugInformation>true</GenerateDebugInformation> | |||
</Link> | |||
<Link Condition="'$(Configuration)'=='Release'"> | |||
<GenerateDebugInformation>true</GenerateDebugInformation> | |||
<EnableCOMDATFolding>true</EnableCOMDATFolding> | |||
<OptimizeReferences>true</OptimizeReferences> | |||
</Link> | |||
<Link> | |||
<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies> | |||
<AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> | |||
</Link> | |||
<!-- Post-build hook to run commands --> | |||
<PostBuildEvent Condition="'$(Platform)'=='Win32' Or '$(Platform)'=='x64'"> | |||
<Command Condition="'$(enable_sdl)'!='no'"> | |||
rem do nothing | |||
</Command> | |||
</PostBuildEvent> | |||
</ItemDefinitionGroup> | |||
</Project> |
@@ -1,176 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<ImportGroup Label="PropertySheets" /> | |||
<PropertyGroup Label="UserMacros"> | |||
<ExternalDir>$(LolDir)\external</ExternalDir> | |||
<PlatformCode Condition="'$(Platform)'=='Win32'">i686</PlatformCode> | |||
<PlatformCode Condition="'$(Platform)'=='x64'">x86_64</PlatformCode> | |||
<!-- PEGTL --> | |||
<PegtlDir>$(LolDir)\src/3rdparty\pegtl\include</PegtlDir> | |||
<PegtlIncludes>$(PegtlDir)</PegtlIncludes> | |||
<!-- imgui --> | |||
<ImguiDir>$(LolDir)\src\3rdparty\imgui</ImguiDir> | |||
<ImguiIncludes>$(ImguiDir)</ImguiIncludes> | |||
<!-- OpenSSL --> | |||
<OpenSslDir>$(ExternalDir)\openssl-1.1.1d</OpenSslDir> | |||
<!-- cpp-httplib (depends on OpenSSL) --> | |||
<CppHttpDir>$(LolDir)\src/3rdparty\cpp-httplib</CppHttpDir> | |||
<CppHttpIncludes>$(CppHttpDir);$(OpenSslDir)\include</CppHttpIncludes> | |||
<CppHttpLibs>$(OpenSslDir)\lib\$(PlatformCode)-msvc</CppHttpLibs> | |||
<CppHttpDeps>libssl.lib;libcrypto.lib;crypt32.lib</CppHttpDeps> | |||
<Win32Defines>CPPHTTPLIB_OPENSSL_SUPPORT;$(Win32Defines)</Win32Defines> | |||
<!-- GTK+ & GtkGl --> | |||
<GtkDir>$(ExternalDir)\gtk-2.22.1</GtkDir> | |||
<GtkGlDir>$(ExternalDir)\gtkglarea-2.0.1</GtkGlDir> | |||
<GtkIncludes>$(GtkDir)\lib\glib-2.0\include;$(GtkDir)\lib\gtk-2.0\include;$(GtkDir)\include\glib-2.0;$(GtkDir)\include\gtk-2.0;$(GtkDir)\include\cairo;$(GtkDir)\include\pango-1.0;$(GtkDir)\include\gdk-pixbuf-2.0;$(GtkDir)\include\atk-1.0;$(GtkGlDir)\include</GtkIncludes> | |||
<GtkLibs>$(GtkDir)\lib;$(GtkDir)\bin;$(GtkGlDir)\lib</GtkLibs> | |||
<GtkDeps>gobject-2.0.lib;gthread-2.0.lib;glib-2.0.lib;gdk-win32-2.0.lib;gtk-win32-2.0.lib;gtkgl-2.0.lib</GtkDeps> | |||
<!-- Assimp --> | |||
<!-- | |||
<AssimpDir>$(ExternalDir)\assimp-3.1.1</AssimpDir> | |||
<AssimpIncludes>$(AssimpDir)\include</AssimpIncludes> | |||
<AssimpLibs Condition="'$(Platform)'=='Win32'">$(AssimpDir)\lib\win32</AssimpLibs> | |||
<AssimpLibs Condition="'$(Platform)'=='x64'">$(AssimpDir)\lib\x64</AssimpLibs> | |||
<AssimpDeps Condition="'$(Configuration)'=='Release'">zlibstatic.lib;assimp.lib</AssimpDeps> | |||
<AssimpDeps Condition="'$(Configuration)'=='Debug'">zlibstatic.lib;assimp.lib</AssimpDeps> | |||
<Win32Defines>LOL_USE_ASSIMP;$(Win32Defines)</Win32Defines> | |||
--> | |||
<!-- libcaca --> | |||
<CacaDir>$(ExternalDir)\libcaca-0.99.beta18</CacaDir> | |||
<CacaIncludes>$(CacaDir)\include</CacaIncludes> | |||
<CacaLibs>$(CacaDir)\lib\$(PlatformCode)-w64-mingw32</CacaLibs> | |||
<CacaDeps>caca.lib</CacaDeps> | |||
<Win32Defines>CACA_STATIC;$(Win32Defines)</Win32Defines> | |||
<!-- GDI+ --> | |||
<GdiDeps>Gdiplus.lib</GdiDeps> | |||
<Win32Defines>LOL_USE_GDIPLUS;$(Win32Defines)</Win32Defines> | |||
<!-- Xinput --> | |||
<XinputIncludes>$(DXSDK_DIR)\Include</XinputIncludes> | |||
<XinputLibs Condition="'$(Platform)'=='Win32'">$(DXSDK_DIR)\Lib\x86</XinputLibs> | |||
<XinputLibs Condition="'$(Platform)'=='x64'">$(DXSDK_DIR)\Lib\x64</XinputLibs> | |||
<XinputDeps>xinput.lib</XinputDeps> | |||
<Win32Defines>LOL_USE_XINPUT;$(Win32Defines)</Win32Defines> | |||
<!-- Windows-specific --> | |||
<Win32Defines>HAVE_STDIO_H;$(Win32Defines)</Win32Defines> | |||
<!-- PS4-specific --> | |||
<OrbisDefines>HAVE_STDIO_H; | |||
$(OrbisDefines)</OrbisDefines> | |||
</PropertyGroup> | |||
<!-- OpenGL & GLEW --> | |||
<PropertyGroup Condition="'$(enable_gl)'!='no'" Label="UserMacros"> | |||
<GlewDir>$(ExternalDir)\glew-2.1.0</GlewDir> | |||
<GlIncludes>$(GlewDir)\include</GlIncludes> | |||
<GlLibs>$(GlewDir)\lib\$(PlatformCode)-w64-mingw32</GlLibs> | |||
<GlDeps>opengl32.lib;glew32s.lib</GlDeps> | |||
<Win32Defines>HAVE_GL_2X;LOL_USE_GLEW;GLEW_STATIC;$(Win32Defines)</Win32Defines> | |||
</PropertyGroup> | |||
<!-- SDL --> | |||
<PropertyGroup Condition="'$(enable_sdl)'!='no'" Label="UserMacros"> | |||
<SdlDir>$(ExternalDir)\sdl-2.0.9</SdlDir> | |||
<SdlImageDir>$(ExternalDir)\sdl-image-2.0.4</SdlImageDir> | |||
<SdlMixerDir>$(ExternalDir)\sdl-mixer-2.0.4</SdlMixerDir> | |||
<SdlLibDir>$(SdlDir)\lib\$(PlatformCode)-msvc</SdlLibDir> | |||
<SdlImageLibDir>$(SdlImageDir)\lib\$(PlatformCode)-msvc</SdlImageLibDir> | |||
<SdlMixerLibDir>$(SdlMixerDir)\lib\$(PlatformCode)-msvc</SdlMixerLibDir> | |||
<SdlIncludes>$(SdlDir)\include;$(SdlImageDir)\include;$(SdlMixerDir)\include</SdlIncludes> | |||
<SdlLibs>$(SdlLibDir);$(SdlImageLibDir);$(SdlMixerLibDir)</SdlLibs> | |||
<SdlDeps>SDL2.lib;SDL2main.lib;SDL2_image.lib;SDL2_mixer.lib</SdlDeps> | |||
<Win32Defines>HAVE_SDL_H;LOL_USE_SDL;$(Win32Defines)</Win32Defines> | |||
<Win32Defines>LOL_USE_SDL_MIXER;LOL_USE_SDL_IMAGE;$(Win32Defines)</Win32Defines> | |||
</PropertyGroup> | |||
<!-- FFmpeg --> | |||
<PropertyGroup Condition="'$(enable_ffmpeg)'!='no'" Label="UserMacros"> | |||
<FfmpegDir>$(ExternalDir)\ffmpeg-20190130</FfmpegDir> | |||
<FfmpegIncludes>$(FfmpegDir)\include</FfmpegIncludes> | |||
<FfmpegLibs>$(FfmpegDir)\lib\$(PlatformCode)-msvc</FfmpegLibs> | |||
<FfmpegDeps>swscale.lib;avformat.lib;avcodec.lib;swresample.lib;avutil.lib;ws2_32.lib;secur32.lib;bcrypt.lib</FfmpegDeps> | |||
<Win32Defines>LOL_USE_FFMPEG;$(Win32Defines)</Win32Defines> | |||
</PropertyGroup> | |||
<PropertyGroup /> | |||
<ItemDefinitionGroup /> | |||
<ItemGroup> | |||
<BuildMacro Include="ExternalDir"><Value>$(ExternalDir)</Value></BuildMacro> | |||
<BuildMacro Include="PlatformCode"><Value>$(PlatformCode)</Value></BuildMacro> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<BuildMacro Include="PegtlDir"><Value>$(PegtlDir)</Value></BuildMacro> | |||
<BuildMacro Include="PegtlIncludes"><Value>$(PegtlIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="CppHttpDir"><Value>$(CppHttpDir)</Value></BuildMacro> | |||
<BuildMacro Include="CppHttpIncludes"><Value>$(CppHttpIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="ImguiDir"><Value>$(ImguiDir)</Value></BuildMacro> | |||
<BuildMacro Include="ImguiIncludes"><Value>$(ImguiIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="LibGccDir"><Value>$(LibGccDir)</Value></BuildMacro> | |||
<BuildMacro Include="LibGccLibs"><Value>$(LibGccLibs)</Value></BuildMacro> | |||
<BuildMacro Include="LibGccDeps"><Value>$(LibGccDeps)</Value></BuildMacro> | |||
<BuildMacro Include="SdlDir"><Value>$(SdlDir)</Value></BuildMacro> | |||
<BuildMacro Include="SdlImageDir"><Value>$(SdlImageDir)</Value></BuildMacro> | |||
<BuildMacro Include="SdlMixerDir"><Value>$(SdlMixerDir)</Value></BuildMacro> | |||
<BuildMacro Include="SdlIncludes"><Value>$(SdlIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="SdlLibs"><Value>$(SdlLibs)</Value></BuildMacro> | |||
<BuildMacro Include="SdlDeps"><Value>$(SdlDeps)</Value></BuildMacro> | |||
<BuildMacro Include="BtPhysDir"><Value>$(BtPhysDir)</Value></BuildMacro> | |||
<BuildMacro Include="BtPhysIncludes"><Value>$(BtPhysIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="GtkDir"><Value>$(GtkDir)</Value></BuildMacro> | |||
<BuildMacro Include="GtkGlDir"><Value>$(GtkGlDir)</Value></BuildMacro> | |||
<BuildMacro Include="GtkIncludes"><Value>$(GtkIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="GtkLibs"><Value>$(GtkLibs)</Value></BuildMacro> | |||
<BuildMacro Include="GtkDeps"><Value>$(GtkDeps)</Value></BuildMacro> | |||
<BuildMacro Include="FfmpegDir"><Value>$(FfmpegDir)</Value></BuildMacro> | |||
<BuildMacro Include="FfmpegIncludes"><Value>$(FfmpegIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="FfmpegLibs"><Value>$(FfmpegLibs)</Value></BuildMacro> | |||
<BuildMacro Include="FfmpegDeps"><Value>$(FfmpegDeps)</Value></BuildMacro> | |||
<BuildMacro Include="AssimpDir"><Value>$(AssimpDir)</Value></BuildMacro> | |||
<BuildMacro Include="AssimpIncludes"><Value>$(AssimpIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="AssimpLibs"><Value>$(AssimpLibs)</Value></BuildMacro> | |||
<BuildMacro Include="AssimpDeps"><Value>$(AssimpDeps)</Value></BuildMacro> | |||
<BuildMacro Include="CacaDir"><Value>$(CacaDir)</Value></BuildMacro> | |||
<BuildMacro Include="CacaIncludes"><Value>$(CacaIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="CacaLibs"><Value>$(CacaLibs)</Value></BuildMacro> | |||
<BuildMacro Include="CacaDeps"><Value>$(CacaDeps)</Value></BuildMacro> | |||
<BuildMacro Include="GdiDeps"><Value>$(GdiDeps)</Value></BuildMacro> | |||
<BuildMacro Include="GlewDir"><Value>$(GlewDir)</Value></BuildMacro> | |||
<BuildMacro Include="GlIncludes"><Value>$(GlIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="GlLibs"><Value>$(GlLibs)</Value></BuildMacro> | |||
<BuildMacro Include="GlDeps"><Value>$(GlDeps)</Value></BuildMacro> | |||
<BuildMacro Include="XinputIncludes"><Value>$(XinputIncludes)</Value></BuildMacro> | |||
<BuildMacro Include="XinputLibs"><Value>$(XinputLibs)</Value></BuildMacro> | |||
<BuildMacro Include="XinputDeps"><Value>$(XinputDeps)</Value></BuildMacro> | |||
<BuildMacro Include="Win32Defines"><Value>$(Win32Defines)</Value></BuildMacro> | |||
<BuildMacro Include="OrbisDeps"><Value>$(OrbisDeps)</Value></BuildMacro> | |||
<BuildMacro Include="OrbisLibs"><Value>$(OrbisLibs)</Value></BuildMacro> | |||
<BuildMacro Include="OrbisDefines"><Value>$(OrbisDefines)</Value></BuildMacro> | |||
</ItemGroup> | |||
<!-- | |||
- Secret stuff for platforms under NDA | |||
--> | |||
<Import Condition="Exists('$(LolDir)\src\private\nx\msbuild\nx.vars.props')" | |||
Project="$(LolDir)\src\private\nx\msbuild\nx.vars.props" /> | |||
<PropertyGroup> | |||
<BinDir Condition="Exists('$(SolutionDir)\lol')">$(SolutionDir)\binaries</BinDir> | |||
<BinDir Condition="!Exists('$(SolutionDir)\lol')">$(LolDir)\binaries</BinDir> | |||
<OutDir>$(BinDir)\$(Platform) $(PlatformToolset) $(Configuration)\</OutDir> | |||
<IntDir>$(BinDir)\$(Platform) $(PlatformToolset) $(Configuration)\$(ProjectName)\</IntDir> | |||
</PropertyGroup> | |||
</Project> |
@@ -1,37 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<PropertyGroup | |||
Condition="'$(LolFxCompileBeforeTargets)' == '' and '$(LolFxCompileAfterTargets)' == '' and '$(ConfigurationType)' != 'Makefile'"> | |||
<LolFxCompileBeforeTargets>Midl</LolFxCompileBeforeTargets> | |||
<LolFxCompileAfterTargets>CustomBuild</LolFxCompileAfterTargets> | |||
</PropertyGroup> | |||
<PropertyGroup> | |||
<LolFxCompileDependsOn | |||
Condition="'$(ConfigurationType)' != 'Makefile'">_SelectedFiles;$(LolFxCompileDependsOn)</LolFxCompileDependsOn> | |||
</PropertyGroup> | |||
<ItemDefinitionGroup> | |||
<LolFxCompile> | |||
<CommandLineTemplate>@echo off | |||
set D=$(IntDir)%(Filename)%(Extension).cpp | |||
set "name=lolfx_resource_%(RelativeDir)%(Filename)" | |||
set "name=%name:\=_%" | |||
set "name=%name:-=_%" | |||
set "name=%name:.=_%" | |||
echo /* This file was autogenerated. DO NOT MODIFY IT. */ > "%D%" | |||
echo extern "C" { char const *%name% = >> "%D%" | |||
setlocal disabledelayedexpansion | |||
for /F "tokens=1,* delims=`" %%L in ('type "%(Fullpath)"') do ( | |||
set "line=%%L" | |||
setlocal enabledelayedexpansion | |||
echo "!line:"=\"!\n" >> "%D%" | |||
endlocal | |||
) | |||
endlocal | |||
echo ;} >> "%D%"</CommandLineTemplate> | |||
<Outputs>$(IntDir)%(FileName)%(Extension).cpp</Outputs> | |||
<ExecutionDescription>%(FileName)%(Extension)</ExecutionDescription> | |||
</LolFxCompile> | |||
</ItemDefinitionGroup> | |||
</Project> |
@@ -1,80 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<ItemGroup> | |||
<PropertyPageSchema Include="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml" /> | |||
<AvailableItemName Include="LolFxCompile"> | |||
<Targets>LolFxCompile</Targets> | |||
</AvailableItemName> | |||
</ItemGroup> | |||
<PropertyGroup> | |||
<ComputeCompileInputsTargets> | |||
$(ComputeCompileInputsTargets); | |||
ComputeLolFxCompileOutput; | |||
</ComputeCompileInputsTargets> | |||
</PropertyGroup> | |||
<UsingTask | |||
TaskName="LolFxCompile" | |||
TaskFactory="XamlTaskFactory" | |||
AssemblyName="Microsoft.Build.Tasks.v4.0"> | |||
<Task>$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml</Task> | |||
</UsingTask> | |||
<Target | |||
Name="LolFxCompile" | |||
BeforeTargets="$(LolFxCompileBeforeTargets)" | |||
AfterTargets="$(LolFxCompileAfterTargets)" | |||
Condition="'@(LolFxCompile)' != ''" | |||
DependsOnTargets="$(LolFxCompileDependsOn);ComputeLolFxCompileOutput" | |||
Outputs="@(LolFxCompile->Metadata('CompileOut')->Distinct())" | |||
Inputs="@(LolFxCompile);%(LolFxCompile.AdditionalDependencies);$(MSBuildProjectFile)"> | |||
<ItemGroup | |||
Condition="'@(SelectedFiles)' != ''"> | |||
<LolFxCompile | |||
Remove="@(LolFxCompile)" | |||
Condition="'%(Identity)' != '@(SelectedFiles)'" /> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<LolFxCompile_tlog | |||
Include="%(LolFxCompile.Outputs)" | |||
Condition="'%(LolFxCompile.Outputs)' != '' and '%(LolFxCompile.ExcludedFromBuild)' != 'true'"> | |||
<Source>@(LolFxCompile, '|')</Source> | |||
</LolFxCompile_tlog> | |||
</ItemGroup> | |||
<Message | |||
Importance="High" | |||
Text="%(LolFxCompile.ExecutionDescription)" /> | |||
<WriteLinesToFile | |||
Condition="'@(LolFxCompile_tlog)' != '' and '%(LolFxCompile_tlog.ExcludedFromBuild)' != 'true'" | |||
File="$(IntDir)$(ProjectName).write.1.tlog" | |||
Lines="^%(LolFxCompile_tlog.Source);@(LolFxCompile_tlog->'%(Fullpath)')" /> | |||
<ItemGroup> | |||
<LolFxCompile> | |||
</LolFxCompile> | |||
</ItemGroup> | |||
<LolFxCompile | |||
Condition="'@(LolFxCompile)' != '' and '%(LolFxCompile.ExcludedFromBuild)' != 'true'" | |||
CommandLineTemplate="%(LolFxCompile.CommandLineTemplate)" | |||
Outputs="%(LolFxCompile.Outputs)" | |||
IntDir="$(IntDir)" | |||
FileName="%(FileName)" | |||
Inputs="@(LolFxCompile)" /> | |||
</Target> | |||
<Target Name="ComputeLolFxCompileOutput" Condition="'@(LolFxCompile)' != ''"> | |||
<ItemGroup> | |||
<ClCompile Include="@(LolFxCompile->Metadata('CompileOut')->Distinct()->ClearMetadata())" Condition="'%(LolFxCompile.ExcludedFromBuild)' != 'true'"> | |||
<CompileAs>CompileAsC</CompileAs> | |||
</ClCompile> | |||
<ClCompile Include="%(LolFxCompile.Outputs)" /> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<LolFxCompile> | |||
<CompileOut>$(IntDir)\%(FileName).lolfx.cpp</CompileOut> | |||
</LolFxCompile> | |||
</ItemGroup> | |||
</Target> | |||
</Project> |
@@ -1,79 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<ProjectSchemaDefinitions xmlns="clr-namespace:Microsoft.Build.Framework.XamlTypes;assembly=Microsoft.Build.Framework" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:sys="clr-namespace:System;assembly=mscorlib" xmlns:transformCallback="Microsoft.Cpp.Dev10.ConvertPropertyCallback"> | |||
<Rule | |||
Name="LolFxCompile" | |||
PageTemplate="tool" | |||
DisplayName="Lol Fx Build Rule v0.0" | |||
Order="200"> | |||
<Rule.DataSource> | |||
<DataSource | |||
Persistence="ProjectFile" | |||
ItemType="LolFxCompile" /> | |||
</Rule.DataSource> | |||
<Rule.Categories> | |||
<Category | |||
Name="General"> | |||
<Category.DisplayName> | |||
<sys:String>General</sys:String> | |||
</Category.DisplayName> | |||
</Category> | |||
<Category | |||
Name="Command Line" | |||
Subtype="CommandLine"> | |||
<Category.DisplayName> | |||
<sys:String>Command Line</sys:String> | |||
</Category.DisplayName> | |||
</Category> | |||
</Rule.Categories> | |||
<StringListProperty | |||
Name="Inputs" | |||
Category="Command Line" | |||
IsRequired="true" | |||
Switch=" "> | |||
<StringListProperty.DataSource> | |||
<DataSource | |||
Persistence="ProjectFile" | |||
ItemType="LolFxCompile" | |||
SourceType="Item" /> | |||
</StringListProperty.DataSource> | |||
</StringListProperty> | |||
<StringListProperty | |||
Name="IntDir" | |||
Category="Command Line" | |||
IsRequired="true" | |||
Switch=" "> | |||
<StringListProperty.DataSource> | |||
<DataSource | |||
Persistence="ProjectFile" | |||
ItemType="LolFxCompile" | |||
SourceType="Item" /> | |||
</StringListProperty.DataSource> | |||
</StringListProperty> | |||
<StringListProperty | |||
Name="FileName" | |||
Category="Command Line" | |||
IsRequired="true" | |||
Switch=" "> | |||
</StringListProperty> | |||
<StringProperty | |||
Name="Outputs" | |||
Category="Command Line" | |||
IsRequired="true" | |||
Switch=" " /> | |||
<StringProperty | |||
Name="CommandLineTemplate" | |||
DisplayName="Command Line" | |||
Visible="False" | |||
IncludeInCommandLine="False" /> | |||
</Rule> | |||
<ItemType | |||
Name="LolFxCompile" | |||
DisplayName="Lol Fx Build Rule v0.0" /> | |||
<FileExtension | |||
Name="*.lolfx" | |||
ContentType="LolFxCompile" /> | |||
<ContentType | |||
Name="LolFxCompile" | |||
DisplayName="Lol Fx Build Rule v0.0" | |||
ItemType="LolFxCompile" /> | |||
</ProjectSchemaDefinitions> |
@@ -1,240 +0,0 @@ | |||
#!/bin/sh | |||
tmpdir="$TMPDIR" | |||
if [ -z "${tmpdir}" ]; then tmpdir="$TEMP"; fi | |||
if [ -z "${tmpdir}" ]; then tmpdir="$TEMPDIR"; fi | |||
if [ -z "${tmpdir}" ]; then tmpdir="$TMP"; fi | |||
if [ -z "${tmpdir}" ]; then tmpdir="/tmp"; fi | |||
conffile="`mktemp -q "${tmpdir}/lol-bitten-XXXXXXXX" 2>/dev/null`" | |||
if [ "${conffile}" = "" ]; then | |||
conffile="`mktemp 2>/dev/null`" | |||
fi | |||
scriptfile="" | |||
builddir="${tmpdir}/lol-bitten-`whoami`" | |||
url="http://lolengine.net/builds" | |||
# | |||
# Utility functions | |||
# | |||
append() { | |||
echo "$*" >> "${conffile}" | |||
} | |||
cleanup() { | |||
rm -f "${conffile}" "${scriptfile}" | |||
rm -rf "${builddir}" | |||
} | |||
bailout() { | |||
cleanup | |||
# Exit gracefully | |||
exit 0 | |||
} | |||
trap bailout EXIT HUP INT QUIT ABRT KILL ALRM TERM | |||
# | |||
# Fork if necessary | |||
# | |||
if [ "$1" = "--forked" ]; then | |||
shift | |||
scriptfile="$1" | |||
shift | |||
else | |||
cp "$0" "${conffile}" | |||
chmod +x "${conffile}" | |||
exec "${conffile}" --forked "${conffile}" "$@" | |||
exit 0 | |||
fi | |||
# | |||
# Check for command line | |||
# | |||
if [ "$#" != 2 ]; then | |||
echo "Usage: run-bitten.sh <username> <password>" | |||
exit 1 | |||
fi | |||
# | |||
# Clean up working directory | |||
# | |||
cleanup | |||
if [ -e "${builddir}" ]; then | |||
echo "Error: cannot get rid of ${builddir}" | |||
exit 1 | |||
fi | |||
# | |||
# Operating system information | |||
# | |||
append "[os]" | |||
append "name = `uname -srmo 2>/dev/null || uname -srm`" | |||
append "version = 0" | |||
family="`uname -s | tr A-Z a-z`" | |||
case "$family" in | |||
mingw*) family="windows" ;; | |||
darwin*) family="osx" ;; | |||
esac | |||
append "family = $family" | |||
# This random token prevents HTTP conflicts when several instances | |||
# are run from the same machine. | |||
append "token = $$$RANDOM" | |||
append "" | |||
# | |||
# Hardware information | |||
# | |||
append "[machine]" | |||
name="`uname -n | tr A-Z a-z | sed 's/[.].*//'`" | |||
case "$name" in | |||
d*e*s*o*v*) name="putois" ;; | |||
esac | |||
append "name = $name" | |||
processor="`uname -m`" | |||
case "$processor" in | |||
x86_64) processor="amd64" | |||
if test "`getconf LONG_BIT 2>/dev/null`" = 32; then | |||
processor="i386" | |||
fi ;; | |||
i*86) processor="i386" ;; | |||
esac | |||
# Windows defines a lot of crazy shit, try to make sense of it | |||
case "$PROCESSOR_ARCHITECTURE" in | |||
amd64|AMD64) processor="amd64" ;; | |||
x86|X86) processor="i386" ;; | |||
esac | |||
case "$PROCESSOR_ARCHITEW6432" in | |||
amd64|AMD64) processor="amd64" ;; | |||
x86|X86) processor="i386" ;; | |||
esac | |||
append "processor = $processor" | |||
append "" | |||
# | |||
# Authentication information | |||
# | |||
append "[authentication]" | |||
append "username = $1" | |||
append "password = $2" | |||
append "" | |||
# | |||
# Visual Studio configuration | |||
# | |||
# FIXME: we also need to check for the Visual Studio SDK | |||
append "[msvc]" | |||
if [ -n "$VS100COMNTOOLS" ]; then | |||
append "version = 10" | |||
elif [ -n "$VS110COMNTOOLS" ]; then | |||
append "version = 11" | |||
elif [ -n "$VS90COMNTOOLS" ]; then | |||
append "version = 9" | |||
fi | |||
append "" | |||
# | |||
# iOS development kit | |||
# | |||
append "[ios]" | |||
if [ -d "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS6.1.sdk" ]; then | |||
append "version = 6.1" | |||
fi | |||
append "" | |||
# | |||
# mingw32 / mingw-w64 | |||
# | |||
append "[mingw64]" | |||
if x86_64-w64-mingw32-g++ --version >/dev/null 2>&1; then | |||
append "version = $(x86_64-w64-mingw32-g++ --version | sed -ne 's/.*g++ *([^)]*) *//p')" | |||
fi | |||
append "" | |||
append "[mingw32]" | |||
if i686-w64-mingw32-g++ --version >/dev/null 2>&1; then | |||
append "version = $(i686-w64-mingw32-g++ --version | sed -ne 's/.*g++ *([^)]*) *//p')" | |||
fi | |||
append "" | |||
# | |||
# Emscripten | |||
# | |||
append "[emscripten]" | |||
if em++ --version >/dev/null 2>&1; then | |||
append "version = $(em++ --version | sed -ne 's/.*emcc.* \([0-9.]\{1,\}\).*/\1/p')" | |||
fi | |||
append "" | |||
# | |||
# Android NDK | |||
# | |||
append "[ndk]" | |||
if [ "$family" != "windows" ]; then | |||
if [ -f "$ANDROID_NDK_ROOT/RELEASE.TXT" ]; then | |||
append "version = $(cat "$ANDROID_NDK_ROOT/RELEASE.TXT")" | |||
fi | |||
fi | |||
append "" | |||
# | |||
# Raspberry Pi cross-compiler | |||
# | |||
append "[raspi]" | |||
if [ "$family" != "windows" ]; then | |||
if [ -d "$RASPI_SDK_ROOT/tools" ]; then | |||
append "version = 0" | |||
fi | |||
fi | |||
append "" | |||
# | |||
# Show what we just did here | |||
# | |||
cat "${conffile}" | |||
# | |||
# Fix system | |||
# | |||
if [ "$family" = "osx" ]; then | |||
# The version of Subversion shipped by Apple is antique; try to | |||
# use the one in /usr/local/bin instead. | |||
PATH="/usr/local/bin:$PATH" | |||
export PATH | |||
# HACK: the version of llvm-g++ shipped by Apple has an insane | |||
# memory leak; use clang++ instead. | |||
CC="clang" | |||
export CC | |||
CXX="clang++" | |||
export CXX | |||
fi | |||
# | |||
# Launch everything | |||
# | |||
while : ; do | |||
bitten-slave "$url" \ | |||
-f "${conffile}" \ | |||
--name "$name" \ | |||
--work-dir="${builddir}" | |||
rm -rf "${builddir}" | |||
sleep 10 | |||
done | |||
exit 0 | |||
@@ -1,280 +0,0 @@ | |||
dnl | |||
dnl Lol Engine | |||
dnl | |||
dnl Copyright © 2010—2017 Sam Hocevar <sam@hocevar.net> | |||
dnl | |||
dnl Lol Engine is free software. It comes without any warranty, to | |||
dnl the extent permitted by applicable law. You can redistribute it | |||
dnl and/or modify it under the terms of the Do What the Fuck You Want | |||
dnl to Public License, Version 2, as published by the WTFPL Task Force. | |||
dnl See http://www.wtfpl.net/ for more details. | |||
dnl | |||
AC_INIT(lolengine, 0.0) | |||
AC_PREREQ(2.50) | |||
AC_CONFIG_AUX_DIR(.auto) | |||
AC_CANONICAL_SYSTEM | |||
AM_INIT_AUTOMAKE([subdir-objects no-define tar-ustar silent-rules]) | |||
dnl AM_MAINTAINER_MODE | |||
dnl Versioning of the separate software we ship | |||
LOLUNIT_VERSION=0.1 | |||
AC_SUBST(LOLUNIT_VERSION) | |||
AC_SUBST(lol_srcdir, '${top_srcdir}') | |||
AC_SUBST(lol_builddir, '${top_builddir}') | |||
AM_PROG_CC_C_O | |||
AC_PROG_CPP | |||
AC_PROG_CXX | |||
AC_PROG_CXXCPP | |||
AC_PROG_RANLIB | |||
LOL_AC_INIT() | |||
AC_LIBTOOL_WIN32_DLL | |||
AM_PROG_LIBTOOL | |||
AC_LIBTOOL_CXX | |||
dnl Ensure an error is thrown if pkg-config M4 files are not found. | |||
m4_pattern_allow([^PKG_CONFIG_LIBDIR$]) | |||
m4_pattern_forbid([^PKG_CHECK_MODULES$]) | |||
m4_pattern_forbid([^PKG_PROG_PKG_CONFIG$]) | |||
dnl Same for Lol Engine M4 files. | |||
m4_pattern_forbid([^LOL_AC_]) | |||
dnl Do not use PKG_CONFIG_LIBDIR when cross-compiling. | |||
if test "${build}" != "${host}" -a "${PKG_CONFIG_LIBDIR}" = ""; then | |||
export PKG_CONFIG_LIBDIR=/dev/null | |||
fi | |||
dnl AC_PROG_EGREP only exists in autoconf 2.54+, so we use AC_EGREP_CPP right | |||
dnl now otherwise it might be set in an obscure if statement. Same thing for | |||
dnl PKG_PROG_PKG_CONFIG which needs to be called first. | |||
AC_EGREP_CPP(yes, foo) | |||
PKG_PROG_PKG_CONFIG() | |||
dnl Check for a working implementation of sed | |||
AC_PROG_SED | |||
AC_MSG_CHECKING(for a sed that understands \t) | |||
if test "$(echo 'x\x' | "${SED}" 's/.*@<:@^x\t@:>@//')" != x; then | |||
AC_MSG_RESULT(no) | |||
AC_MSG_ERROR([[consider installing GNU sed]]) | |||
else | |||
AC_MSG_RESULT(yes) | |||
fi | |||
dnl conditional builds | |||
AC_ARG_ENABLE(debug, | |||
[ --enable-debug build debug versions of the game (default no)]) | |||
AC_ARG_ENABLE(release, | |||
[ --enable-release build final release of the game (default no)]) | |||
AC_ARG_ENABLE(experimental, | |||
[ --enable-experimental experimental build (default no)]) | |||
AC_ARG_ENABLE(subproject, | |||
[ --enable-subproject build as a subproject (default no)]) | |||
AC_ARG_ENABLE(gl, | |||
[ --enable-gl build using OpenGL or OpenGL ES (default autodetected)]) | |||
AC_ARG_ENABLE(ffmpeg, | |||
[ --enable-ffmpeg build using FFmpeg (default autodetected)]) | |||
AC_ARG_ENABLE(sdl, | |||
[ --enable-sdl build using SDL (default autodetected)]) | |||
AC_ARG_ENABLE(imlib2, | |||
[ --enable-imlib2 build using Imlib2 (default autodetected)]) | |||
AC_ARG_ENABLE(png, | |||
[ --enable-png build using libpng (default autodetected)]) | |||
AC_ARG_ENABLE(bullet, | |||
[ --enable-bullet build using Bullet Physics (default yes)]) | |||
AC_ARG_ENABLE(test, | |||
[ --enable-test build test suite (default yes)]) | |||
AC_ARG_ENABLE(tools, | |||
[ --enable-tools build miscellaneous tools (default yes)]) | |||
AC_ARG_ENABLE(tutorial, | |||
[ --enable-tutorial build tutorial applications (default yes)]) | |||
AC_ARG_ENABLE(samples, | |||
[ --enable-samples build sample applications (default yes)]) | |||
AC_ARG_ENABLE(doc, | |||
[ --enable-doc build documentation (needs doxygen and LaTeX)]) | |||
dnl Subproject builds | |||
if test "${enable_subproject}" = "yes"; then | |||
AC_MSG_CHECKING(for a config-lol.h file in the parent project) | |||
if test -f "../config-lol.h"; then | |||
AC_MSG_RESULT(yes) | |||
AC_DEFINE(HAVE_CONFIG_LOL_H, 1, Define to if parent project provides config-lol.h) | |||
AH_BOTTOM([ | |||
#if HAVE_CONFIG_LOL_H | |||
#include "../config-lol.h" | |||
#endif | |||
]) | |||
else | |||
AC_MSG_RESULT(no) | |||
fi | |||
fi | |||
dnl Common C headers | |||
AC_CHECK_HEADERS(stdio.h stdarg.h inttypes.h stdint.h math.h) | |||
AC_CHECK_HEADERS(fastmath.h unistd.h io.h) | |||
AC_CHECK_HEADERS(execinfo.h) | |||
AC_CHECK_HEADERS(sys/ioctl.h sys/ptrace.h sys/stat.h sys/syscall.h sys/user.h) | |||
AC_CHECK_HEADERS(sys/wait.h sys/time.h sys/types.h) | |||
dnl Common C++ headers | |||
AC_LANG_PUSH(C++) | |||
AC_CHECK_HEADERS(cxxabi.h) | |||
AC_LANG_POP(C++) | |||
dnl Common C functions | |||
AC_CHECK_FUNCS(getenv system tmpfile tmpnam getcwd _getcwd) | |||
AC_CHECK_FUNCS(backtrace_symbols) | |||
AC_CHECK_FUNCS(gettimeofday usleep) | |||
dnl Build mode | |||
ac_cv_my_build_mode="devel" | |||
if test "x${enable_release}" = "xyes"; then | |||
ac_cv_my_build_mode="release" | |||
fi | |||
if test "x${enable_devel}" = "xyes"; then | |||
ac_cv_my_build_mode="devel" | |||
fi | |||
if test "x${enable_debug}" = "xyes"; then | |||
ac_cv_my_build_mode="debug" | |||
fi | |||
if test "x${ac_cv_my_build_mode}" = "xdebug"; then | |||
AC_DEFINE(LOL_BUILD_DEBUG, 1, Define to 1 to activate debug build) | |||
LOL_TRY_CXXFLAGS(-O, [AM_CXXFLAGS="${AM_CXXFLAGS} -O"]) | |||
LOL_TRY_CXXFLAGS(-g, [AM_CXXFLAGS="${AM_CXXFLAGS} -g"]) | |||
elif test "x${ac_cv_my_build_mode}" = "xdevel"; then | |||
AC_DEFINE(LOL_BUILD_DEVEL, 1, Define to 1 to activate development build) | |||
LOL_TRY_CXXFLAGS(-Os, [AM_CXXFLAGS="${AM_CXXFLAGS} -Os"]) | |||
LOL_TRY_CXXFLAGS(-g, [AM_CXXFLAGS="${AM_CXXFLAGS} -g"]) | |||
LOL_TRY_CXXFLAGS(-ffast-math, [AM_CXXFLAGS="${AM_CXXFLAGS} -ffast-math"]) | |||
else | |||
AC_DEFINE(LOL_BUILD_RELEASE, 1, Define to 1 to activate final release) | |||
LOL_TRY_CXXFLAGS(-Os, [AM_CXXFLAGS="${AM_CXXFLAGS} -Os"]) | |||
LOL_TRY_CXXFLAGS(-ffast-math, [AM_CXXFLAGS="${AM_CXXFLAGS} -ffast-math"]) | |||
LOL_TRY_CXXFLAGS(-fomit-frame-pointer, [AM_CXXFLAGS="${AM_CXXFLAGS} -fomit-frame-pointer"]) | |||
LOL_TRY_CXXFLAGS(-fno-strength-reduce, [AM_CXXFLAGS="${AM_CXXFLAGS} -fno-strength-reduce"]) | |||
fi | |||
dnl Build documentation? | |||
DOXYGEN="no" | |||
LATEX="no" | |||
if test "${enable_doc}" != "no" -a "${enable_subproject}" != "yes"; then | |||
AC_PATH_PROG(DOXYGEN, doxygen, no) | |||
if test "${DOXYGEN}" != "no"; then | |||
# Build LaTeX documentation? | |||
AC_PATH_PROG(LATEX, pdflatex, no) | |||
AC_PATH_PROG(KPSEWHICH, kpsewhich, no) | |||
AC_PATH_PROG(DVIPS, dvips, no) | |||
if test "${DVIPS}" = "no" -o "${KPSEWHICH}" = "no"; then | |||
LATEX="no" | |||
fi | |||
if test "${LATEX}" != "no"; then | |||
AC_MSG_CHECKING(for a4.sty and a4wide.sty) | |||
if "${KPSEWHICH}" a4.sty >/dev/null 2>&1; then | |||
if "${KPSEWHICH}" a4wide.sty >/dev/null 2>&1; then | |||
AC_MSG_RESULT(yes) | |||
else | |||
LATEX="no" | |||
AC_MSG_RESULT(no) | |||
fi | |||
else | |||
LATEX="no" | |||
AC_MSG_RESULT(no) | |||
fi | |||
fi | |||
AC_PATH_PROG(DOT, dot, no) | |||
if test "${DOT}" != "no"; then | |||
LOL_USE_DOT="YES" | |||
else | |||
LOL_USE_DOT="NO" | |||
fi | |||
fi | |||
fi | |||
dnl XXX: disable LaTeX because we use too much memory | |||
LATEX=no | |||
AM_CONDITIONAL(BUILD_DOCUMENTATION, test "${DOXYGEN}" != "no") | |||
AM_CONDITIONAL(LOL_USE_LATEX, test "${LATEX}" != "no") | |||
AM_CONDITIONAL(LOL_USE_DOT, test "${DOT}" != "no") | |||
AC_SUBST(LOL_USE_DOT) | |||
dnl GCC-specific symbol demangling | |||
AC_LANG_PUSH(C++) | |||
AC_TRY_LINK( | |||
[#include <cxxabi.h>], | |||
[abi::__cxa_demangle(NULL, 0, 0, NULL);], | |||
[AC_DEFINE(HAVE_CXA_DEMANGLE, 1, Define to 1 if abi::__cxa_demangle is available)]) | |||
AC_LANG_POP(C++) | |||
LOL_AC_CHECK() | |||
dnl Use libcaca? (required for font generation) | |||
ac_cv_my_have_caca="no" | |||
PKG_CHECK_MODULES(CACA, caca >= 0.99.beta17, [ac_cv_my_have_caca="yes"], [:]) | |||
if test "${ac_cv_my_have_caca}" != "no"; then | |||
AC_DEFINE(LOL_USE_CACA, 1, Define to 1 to use libcaca) | |||
fi | |||
AM_CONDITIONAL(LOL_USE_CACA, test "${ac_cv_my_have_caca}" != "no") | |||
dnl Use GTK+? (required for the deushax editor) | |||
ac_cv_my_have_gtkgl="no" | |||
PKG_CHECK_MODULES(GTK, gtk+-2.0, [ac_cv_my_have_gtkgl="yes"], [:]) | |||
PKG_CHECK_MODULES(GTKGL, gtkgl-2.0, [:], [ac_cv_my_have_gtkgl="no"]) | |||
if test "${ac_cv_my_have_gtkgl}" != "no"; then | |||
AC_DEFINE(LOL_USE_GTKGL, 1, Define to 1 to use GtkGl) | |||
fi | |||
AM_CONDITIONAL(LOL_USE_GTKGL, test "${ac_cv_my_have_gtkgl}" != "no") | |||
dnl Optional features | |||
AM_CONDITIONAL(BUILD_TEST, test "${enable_test}" != "no" -a "${enable_subproject}" != "yes") | |||
AM_CONDITIONAL(BUILD_TOOLS, test "${enable_tools}" != "no" -a "${enable_subproject}" != "yes") | |||
AM_CONDITIONAL(BUILD_TUTORIAL, test "${enable_tutorial}" != "no" -a "${enable_subproject}" != "yes") | |||
AM_CONDITIONAL(BUILD_SAMPLES, test "${enable_samples}" != "no" -a "${enable_subproject}" != "yes") | |||
LOL_AC_FINI() | |||
AC_CONFIG_HEADER(config.h) | |||
AC_CONFIG_FILES( | |||
[Makefile | |||
src/Makefile | |||
src/3rdparty/Makefile | |||
src/data/Makefile | |||
src/data/font/Makefile | |||
src/t/Makefile | |||
build/Makefile | |||
binaries/Makefile | |||
doc/Makefile | |||
doc/doxygen.cfg | |||
doc/samples/Makefile | |||
doc/samples/math/Makefile | |||
doc/samples/sandbox/Makefile | |||
doc/tutorial/Makefile | |||
tools/Makefile | |||
tools/lolunit/Makefile | |||
tools/vimlol/Makefile | |||
tools/vslol/Makefile | |||
]) | |||
AC_OUTPUT | |||
@@ -1,68 +0,0 @@ | |||
include $(top_srcdir)/build/autotools/common.am | |||
SUBDIRS = | |||
SUBDIRS += tutorial | |||
SUBDIRS += samples | |||
EXTRA_DIST += doxygen.cfg.in doxygen.css footer.html header.html \ | |||
$(man_MANS) $(doxygen_DOX) | |||
CLEANFILES += doxygen.log stamp-latex stamp-doxygen | |||
doxygen_DOX = lolengine.dox | |||
if BUILD_DOCUMENTATION | |||
man_MANS = lolengine.1 | |||
endif | |||
if BUILD_DOCUMENTATION | |||
htmldoc_DATA = html/doxygen.css | |||
htmldocdir = $(datadir)/doc/lolengine-dev/html | |||
if LOL_USE_LATEX | |||
pdfdoc_DATA = latex/lolengine.pdf | |||
pdfdocdir = $(datadir)/doc/lolengine-dev/pdf | |||
endif | |||
endif | |||
html/doxygen.css html/doxygen.png: stamp-doxygen | |||
latex/lolengine.pdf: stamp-latex | |||
stamp-doxygen: $(doxygen_DOX) | |||
if BUILD_DOCUMENTATION | |||
doxygen doxygen.cfg 2>&1 | tee doxygen.log | |||
touch stamp-doxygen | |||
endif | |||
stamp-latex: stamp-doxygen | |||
if BUILD_DOCUMENTATION | |||
if LOL_USE_LATEX | |||
rm -f latex/lolengine.tex latex/lolengine.pdf | |||
$(SED) -i -e 's/setlength{/renewcommand{/' latex/refman.tex | |||
$(SED) -i -e 's/.*usepackage.*times.*//' latex/refman.tex | |||
$(SED) -i -e 's/latex refman/latex -file-line-error -halt-on-error refman/' latex/Makefile | |||
cd latex && $(MAKE) $(AM_CFLAGS) refman.pdf || (cat refman.log; exit 1) | |||
mv latex/refman.pdf latex/lolengine.pdf | |||
touch stamp-latex | |||
endif | |||
endif | |||
clean-local: | |||
-rm -Rf html latex man | |||
install-data-local: | |||
if BUILD_DOCUMENTATION | |||
mkdir -p $(DESTDIR)$(datadir)/doc | |||
$(mkinstalldirs) $(DESTDIR)$(datadir)/doc/lolengine-dev/html | |||
cp `find html -name '*.html' -o -name '*.gif' -o -name '*.png'` \ | |||
$(DESTDIR)$(datadir)/doc/lolengine-dev/html | |||
$(mkinstalldirs) $(DESTDIR)$(mandir)/man3 | |||
for man in $$(find man -name '*.3lol'); do \ | |||
sed -e 's/man3lol/man3/g' -e "s/fC'\([a-zA-Z0-9]*\)'/fC\"\1\"/g" \ | |||
$$man >$(DESTDIR)$(mandir)/man3/$${man##*/}; \ | |||
done | |||
$(mkinstalldirs) $(DESTDIR)$(mandir)/man1 | |||
endif | |||
uninstall-local: | |||
rmdir $(DESTDIR)$(datadir)/doc/lolengine-dev/html 2>/dev/null || true | |||
rmdir $(DESTDIR)$(datadir)/doc/lolengine-dev 2>/dev/null || true | |||
rmdir $(DESTDIR)$(datadir)/doc 2>/dev/null || true | |||
@@ -1,2 +0,0 @@ | |||
</body> | |||
</html> |
@@ -1 +0,0 @@ | |||
This directory contains old grammars for languages we used to parse. |
@@ -1,328 +0,0 @@ | |||
%{ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net> | |||
// (c) 2009-2013 Cédric Lecacheur <jordx@free.fr> | |||
// (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com> | |||
// This program is free software; you can redistribute it and/or | |||
// modify it under the terms of the Do What The Fuck You Want To | |||
// Public License, Version 2, as published by Sam Hocevar. See | |||
// http://www.wtfpl.net/ for more details. | |||
// | |||
#if defined HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include "core.h" | |||
#include "easymesh/easymesh.h" | |||
#include <string> | |||
%} | |||
%require "2.3" | |||
%debug | |||
%defines | |||
%skeleton "lalr1.cc" | |||
%name-prefix="lol" | |||
%define parser_class_name "EasyMeshParser" | |||
%locations | |||
%parse-param { class EasyMeshCompiler& mc } | |||
%error-verbose | |||
%union | |||
{ | |||
float fval; | |||
int ival; | |||
bool bval; | |||
float vval[4]; | |||
int ivval[4]; | |||
char* lval; | |||
/* Can't use uin32_t here for some reason */ | |||
unsigned u32val; | |||
} | |||
%start mesh_description | |||
%token T_LOOP T_COLOR T_ACOLOR T_BCOLOR T_VCOLOR | |||
%token T_TOGGLESCALEWINDING T_TOGGLEQUADWEIGHTING T_TOGGLEPOSTBUILDNORMAL T_TOGGLEVERTNOCLEANUP | |||
%token T_VERTMERGE T_VERTSEPARATE | |||
%token T_TRANSLATEX T_ROTATEX T_TAPERX T_TWISTX T_SHEARX T_STRETCHX T_BENDXY T_BENDXZ T_SCALEX T_MIRRORX | |||
%token T_TRANSLATEY T_ROTATEY T_TAPERY T_TWISTY T_SHEARY T_STRETCHY T_BENDYX T_BENDYZ T_SCALEY T_MIRRORY | |||
%token T_TRANSLATEZ T_ROTATEZ T_TAPERZ T_TWISTZ T_SHEARZ T_STRETCHZ T_BENDZX T_BENDZY T_SCALEZ T_MIRRORZ | |||
%token T_TRANSLATE T_ROTATE T_SCALE T_RADIALJITTER T_SPLITTRIANGLE T_SMOOTHMESH | |||
%token T_DUPLICATE | |||
%token T_CSGUNION T_CSGSUBSTRACT T_CSGSUBSTRACTLOSS T_CSGAND T_CSGXOR | |||
%token T_CHAMFER | |||
%token T_CYLINDER T_BOX T_SMOOTHCHAMFBOX T_FLATCHAMFBOX T_SPHERE T_CAPSULE | |||
%token T_STAR T_EXPANDEDSTAR T_DISC T_TRIANGLE T_QUAD T_COG T_TORUS | |||
%token T_END 0 | |||
%token T_ERROR | |||
%token <fval> F_NUMBER | |||
%token <ival> I_NUMBER | |||
%token <bval> BOOLEAN | |||
%token <u32val> COLOR | |||
/* Base Number types */ | |||
%type <fval> fv | |||
%type <ival> iv | |||
/* Vector types */ | |||
%type <vval> v2 | |||
%type <vval> v3 | |||
%type <vval> v4 | |||
/* Special types */ | |||
%type <bval> bv | |||
%{ | |||
#include "easymesh/easymesh-compiler.h" | |||
#undef yylex | |||
#define yylex mc.m_lexer->lex | |||
/* HACK: workaround for Bison who insists on using exceptions */ | |||
#define try if (true) | |||
#define catch(...) if (false) | |||
#define throw (void)0 | |||
%} | |||
%% | |||
mesh_description: | |||
mesh_expression_list T_END | |||
; | |||
mesh_expression_list: | |||
mesh_expression | |||
| mesh_expression mesh_expression_list | |||
; | |||
mesh_expression: | |||
mesh_command_list | |||
| mesh_open mesh_expression_list mesh_close | |||
; | |||
mesh_command_list: | |||
mesh_command | |||
| mesh_command mesh_command_list | |||
; | |||
mesh_command: | |||
color_command | |||
| transform_command | |||
| primitive_command | |||
| post_brace_command | |||
| pre_brace_command '[' mesh_expression_list mesh_close | |||
| doloop '[' mesh_expression_list ']' { mc.m_mesh.LoopEnd(); } | |||
; | |||
post_brace_command: | |||
T_CSGUNION mesh_open mesh_expression_list ']' { mc.m_mesh.CsgUnion(); mc.m_mesh.CloseBrace(); } | |||
| T_CSGSUBSTRACT mesh_open mesh_expression_list ']' { mc.m_mesh.CsgSub(); mc.m_mesh.CloseBrace(); } | |||
| T_CSGSUBSTRACTLOSS mesh_open mesh_expression_list ']' { mc.m_mesh.CsgSubL(); mc.m_mesh.CloseBrace(); } | |||
| T_CSGAND mesh_open mesh_expression_list ']' { mc.m_mesh.CsgAnd(); mc.m_mesh.CloseBrace(); } | |||
| T_CSGXOR mesh_open mesh_expression_list ']' { mc.m_mesh.CsgXor(); mc.m_mesh.CloseBrace(); } | |||
; | |||
doloop: | |||
T_LOOP iv { mc.m_mesh.LoopStart($2); } | |||
; | |||
pre_brace_command: | |||
T_DUPLICATE { mc.m_mesh.DupAndScale(vec3(1.f), true); } | |||
; | |||
mesh_open: | |||
'[' { mc.m_mesh.OpenBrace(); } | |||
; | |||
mesh_close: | |||
']' { mc.m_mesh.CloseBrace(); } | |||
; | |||
color_command: | |||
T_COLOR fv fv fv fv { mc.m_mesh.SetCurColor(vec4($2, $3, $4, $5)); } | |||
| T_COLOR v4 { mc.m_mesh.SetCurColor(vec4($2[0], $2[1], $2[2], $2[3])); } | |||
| T_COLOR COLOR { uint32_t x = $2; | |||
ivec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff); | |||
mc.m_mesh.SetCurColor(vec4(v) * (1.f / 255.f)); } | |||
| T_ACOLOR fv fv fv fv { mc.m_mesh.SetCurColorA(vec4($2, $3, $4, $5)); } | |||
| T_ACOLOR v4 { mc.m_mesh.SetCurColorA(vec4($2[0], $2[1], $2[2], $2[3])); } | |||
| T_ACOLOR COLOR { uint32_t x = $2; | |||
ivec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff); | |||
mc.m_mesh.SetCurColorA(vec4(v) * (1.f / 255.f)); } | |||
| T_BCOLOR fv fv fv fv { mc.m_mesh.SetCurColorB(vec4($2, $3, $4, $5)); } | |||
| T_BCOLOR v4 { mc.m_mesh.SetCurColorB(vec4($2[0], $2[1], $2[2], $2[3])); } | |||
| T_BCOLOR COLOR { uint32_t x = $2; | |||
ivec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff); | |||
mc.m_mesh.SetCurColorB(vec4(v) * (1.f / 255.f)); } | |||
| T_VCOLOR fv fv fv fv { mc.m_mesh.SetVertColor(vec4($2, $3, $4, $5)); } | |||
| T_VCOLOR v4 { mc.m_mesh.SetVertColor(vec4($2[0], $2[1], $2[2], $2[3])); } | |||
| T_VCOLOR COLOR { uint32_t x = $2; | |||
ivec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff); | |||
mc.m_mesh.SetVertColor(vec4(v) * (1.f / 255.f)); } | |||
; | |||
transform_command: | |||
T_TRANSLATEX fv { mc.m_mesh.Translate(vec3($2, 0.f, 0.f)); } | |||
| T_TRANSLATEY fv { mc.m_mesh.Translate(vec3(0.f, $2, 0.f)); } | |||
| T_TRANSLATEZ fv { mc.m_mesh.Translate(vec3(0.f, 0.f, $2)); } | |||
| T_TRANSLATE fv fv fv { mc.m_mesh.Translate(vec3($2, $3, $4)); } | |||
| T_TRANSLATE v3 { mc.m_mesh.Translate(vec3($2[0], $2[1], $2[2])); } | |||
| T_ROTATEX fv { mc.m_mesh.RotateX($2); } | |||
| T_ROTATEY fv { mc.m_mesh.RotateY($2); } | |||
| T_ROTATEZ fv { mc.m_mesh.RotateZ($2); } | |||
| T_ROTATE fv fv fv fv { mc.m_mesh.Rotate($2, vec3($3, $4, $5)); } | |||
| T_ROTATE fv v3 { mc.m_mesh.Rotate($2, vec3($3[0], $3[1], $3[2])); } | |||
| T_RADIALJITTER fv { mc.m_mesh.RadialJitter($2); } | |||
| T_TAPERX fv fv fv bv { mc.m_mesh.TaperX($2, $3, $4, $5); } | |||
| T_TAPERX fv fv fv { mc.m_mesh.TaperX($2, $3, $4); } | |||
| T_TAPERX fv fv { mc.m_mesh.TaperX($2, $3); } | |||
| T_TAPERY fv fv fv bv { mc.m_mesh.TaperY($2, $3, $4, $5); } | |||
| T_TAPERY fv fv fv { mc.m_mesh.TaperY($2, $3, $4); } | |||
| T_TAPERY fv fv { mc.m_mesh.TaperY($2, $3); } | |||
| T_TAPERZ fv fv fv bv { mc.m_mesh.TaperZ($2, $3, $4, $5); } | |||
| T_TAPERZ fv fv fv { mc.m_mesh.TaperZ($2, $3, $4); } | |||
| T_TAPERZ fv fv { mc.m_mesh.TaperZ($2, $3); } | |||
| T_TWISTX fv fv { mc.m_mesh.TwistX($2, $3); } | |||
| T_TWISTX fv { mc.m_mesh.TwistX($2); } | |||
| T_TWISTY fv fv { mc.m_mesh.TwistY($2, $3); } | |||
| T_TWISTY fv { mc.m_mesh.TwistY($2); } | |||
| T_TWISTZ fv fv { mc.m_mesh.TwistZ($2, $3); } | |||
| T_TWISTZ fv { mc.m_mesh.TwistZ($2); } | |||
| T_SHEARX fv fv fv bv { mc.m_mesh.ShearX($2, $3, $4, $5); } | |||
| T_SHEARX fv fv fv { mc.m_mesh.ShearX($2, $3, $4); } | |||
| T_SHEARX fv fv { mc.m_mesh.ShearX($2, $3); } | |||
| T_SHEARY fv fv fv bv { mc.m_mesh.ShearY($2, $3, $4, $5); } | |||
| T_SHEARY fv fv fv { mc.m_mesh.ShearY($2, $3, $4); } | |||
| T_SHEARY fv fv { mc.m_mesh.ShearY($2, $3); } | |||
| T_SHEARZ fv fv fv bv { mc.m_mesh.ShearZ($2, $3, $4, $5); } | |||
| T_SHEARZ fv fv fv { mc.m_mesh.ShearZ($2, $3, $4); } | |||
| T_SHEARZ fv fv { mc.m_mesh.ShearZ($2, $3); } | |||
| T_STRETCHX fv fv fv { mc.m_mesh.StretchX($2, $3, $4); } | |||
| T_STRETCHX fv fv { mc.m_mesh.StretchX($2, $3); } | |||
| T_STRETCHY fv fv fv { mc.m_mesh.StretchY($2, $3, $4); } | |||
| T_STRETCHY fv fv { mc.m_mesh.StretchY($2, $3); } | |||
| T_STRETCHZ fv fv fv { mc.m_mesh.StretchZ($2, $3, $4); } | |||
| T_STRETCHZ fv fv { mc.m_mesh.StretchZ($2, $3); } | |||
| T_BENDXY fv fv { mc.m_mesh.BendXY($2, $3); } | |||
| T_BENDXY fv { mc.m_mesh.BendXY($2); } | |||
| T_BENDXZ fv fv { mc.m_mesh.BendXZ($2, $3); } | |||
| T_BENDXZ fv { mc.m_mesh.BendXZ($2); } | |||
| T_BENDYX fv fv { mc.m_mesh.BendYX($2, $3); } | |||
| T_BENDYX fv { mc.m_mesh.BendYX($2); } | |||
| T_BENDYZ fv fv { mc.m_mesh.BendYZ($2, $3); } | |||
| T_BENDYZ fv { mc.m_mesh.BendYZ($2); } | |||
| T_BENDZX fv fv { mc.m_mesh.BendZX($2, $3); } | |||
| T_BENDZX fv { mc.m_mesh.BendZX($2); } | |||
| T_BENDZY fv fv { mc.m_mesh.BendZY($2, $3); } | |||
| T_BENDZY fv { mc.m_mesh.BendZY($2); } | |||
| T_SCALEX fv { mc.m_mesh.Scale(vec3($2, 1.f, 1.f)); } | |||
| T_SCALEY fv { mc.m_mesh.Scale(vec3(1.f, $2, 1.f)); } | |||
| T_SCALEZ fv { mc.m_mesh.Scale(vec3(1.f, 1.f, $2)); } | |||
| T_SCALE fv fv fv { mc.m_mesh.Scale(vec3($2, $3, $4)); } | |||
| T_SCALE v3 { mc.m_mesh.Scale(vec3($2[0], $2[1], $2[2])); } | |||
| T_SCALE fv { mc.m_mesh.Scale(vec3($2, $2, $2)); } | |||
| T_MIRRORX { mc.m_mesh.MirrorX(); } | |||
| T_MIRRORY { mc.m_mesh.MirrorY(); } | |||
| T_MIRRORZ { mc.m_mesh.MirrorZ(); } | |||
| T_CHAMFER fv { mc.m_mesh.Chamfer($2); } | |||
| T_SPLITTRIANGLE iv { mc.m_mesh.SplitTriangles($2); } | |||
| T_SMOOTHMESH iv iv iv { mc.m_mesh.SmoothMesh($2, $3, $4); } | |||
| T_TOGGLESCALEWINDING { mc.m_mesh.ToggleScaleWinding(); } | |||
| T_TOGGLEQUADWEIGHTING { mc.m_mesh.ToggleQuadWeighting(); } | |||
| T_TOGGLEPOSTBUILDNORMAL { mc.m_mesh.TogglePostBuildNormal(); } | |||
| T_TOGGLEVERTNOCLEANUP { mc.m_mesh.ToggleVerticeNoCleanup(); } | |||
| T_VERTMERGE { mc.m_mesh.VerticesMerge(); } | |||
| T_VERTSEPARATE { mc.m_mesh.VerticesSeparate(); } | |||
; | |||
primitive_command: | |||
T_CYLINDER iv fv fv fv bv bv bv { mc.m_mesh.AppendCylinder($2, $3, $4, $5, $6, $7, $8); } | |||
| T_CYLINDER iv fv fv fv bv bv { mc.m_mesh.AppendCylinder($2, $3, $4, $5, $6, $7); } | |||
| T_CYLINDER iv fv fv fv bv { mc.m_mesh.AppendCylinder($2, $3, $4, $5, $6); } | |||
| T_CYLINDER iv fv fv fv { mc.m_mesh.AppendCylinder($2, $3, $4, $5); } | |||
| T_CYLINDER iv fv fv { mc.m_mesh.AppendCylinder($2, $3, $4, $4); } | |||
| T_SPHERE iv fv { mc.m_mesh.AppendSphere($2, $3); } | |||
| T_CAPSULE iv fv fv { mc.m_mesh.AppendCapsule($2, $3, $4); } | |||
| T_TORUS iv fv fv { mc.m_mesh.AppendTorus($2, $3, $4); } | |||
| T_BOX fv fv fv fv { mc.m_mesh.AppendBox(vec3($2, $3, $4), $5); } | |||
| T_BOX fv fv fv { mc.m_mesh.AppendBox(vec3($2, $3, $4)); } | |||
| T_BOX fv { mc.m_mesh.AppendBox(vec3($2, $2, $2)); } | |||
| T_BOX v3 fv { mc.m_mesh.AppendBox(vec3($2[0], $2[1], $2[2]), $3); } | |||
| T_BOX v3 { mc.m_mesh.AppendBox(vec3($2[0], $2[1], $2[2])); } | |||
| T_SMOOTHCHAMFBOX fv fv fv fv { mc.m_mesh.AppendSmoothChamfBox(vec3($2, $3, $4), $5); } | |||
| T_SMOOTHCHAMFBOX fv fv { mc.m_mesh.AppendSmoothChamfBox(vec3($2, $2, $2), $3); } | |||
| T_SMOOTHCHAMFBOX v3 fv { mc.m_mesh.AppendSmoothChamfBox(vec3($2[0], $2[1], $2[2]), $3); } | |||
| T_FLATCHAMFBOX fv fv fv fv { mc.m_mesh.AppendFlatChamfBox(vec3($2, $3, $4), $5); } | |||
| T_FLATCHAMFBOX fv fv { mc.m_mesh.AppendFlatChamfBox(vec3($2, $2, $2), $3); } | |||
| T_FLATCHAMFBOX v3 fv { mc.m_mesh.AppendFlatChamfBox(vec3($2[0], $2[1], $2[2]), $3); } | |||
| T_STAR iv fv fv bv bv { mc.m_mesh.AppendStar($2, $3, $4, $5, $6); } | |||
| T_STAR iv fv fv bv { mc.m_mesh.AppendStar($2, $3, $4, $5); } | |||
| T_STAR iv fv fv { mc.m_mesh.AppendStar($2, $3, $4); } | |||
| T_EXPANDEDSTAR iv fv fv fv { mc.m_mesh.AppendExpandedStar($2, $3, $4, $5); } | |||
| T_EXPANDEDSTAR iv fv fv { mc.m_mesh.AppendExpandedStar($2, $3, $4); } | |||
| T_DISC iv fv bv { mc.m_mesh.AppendDisc($2, $3, $4); } | |||
| T_DISC iv fv { mc.m_mesh.AppendDisc($2, $3); } | |||
| T_TRIANGLE fv bv { mc.m_mesh.AppendSimpleTriangle($2, $3); } | |||
| T_TRIANGLE fv { mc.m_mesh.AppendSimpleTriangle($2); } | |||
| T_QUAD fv bv { mc.m_mesh.AppendSimpleQuad($2, $3); } | |||
| T_QUAD fv { mc.m_mesh.AppendSimpleQuad($2); } | |||
| T_COG iv fv fv fv fv fv fv fv fv bv { mc.m_mesh.AppendCog($2, $3, $4, $5, $6, $7, $8, $9, $10, $11); } | |||
| T_COG iv fv fv fv fv fv fv fv fv { mc.m_mesh.AppendCog($2, $3, $4, $5, $6, $7, $8, $9, $10); } | |||
| T_COG iv fv fv fv fv fv fv fv { mc.m_mesh.AppendCog($2, $3, $4, $5, $6, $7, $8, $9); } | |||
| T_COG iv fv v2 v2 v2 fv bv { mc.m_mesh.AppendCog($2, $3, $4[0], $4[1], $5[0], $5[1], $6[0], $6[1], $7, $8); } | |||
| T_COG iv fv v2 v2 v2 fv { mc.m_mesh.AppendCog($2, $3, $4[0], $4[1], $5[0], $5[1], $6[0], $6[1], $7); } | |||
| T_COG iv fv v2 v2 v2 { mc.m_mesh.AppendCog($2, $3, $4[0], $4[1], $5[0], $5[1], $6[0], $6[1]); } | |||
; | |||
/* Base Number types */ | |||
fv: | |||
F_NUMBER { $$ = $1; } | |||
| '-' fv { $$ = -$2; } | |||
| I_NUMBER { $$ = (float)$1; } | |||
| '-' iv { $$ = -(float)$2; } | |||
; | |||
iv: | |||
I_NUMBER { $$ = $1; } | |||
| '-' iv { $$ = -$2; } | |||
| F_NUMBER { $$ = (int)$1; } | |||
| '-' fv { $$ = -(int)$2; } | |||
; | |||
/* Vector types */ | |||
v2: | |||
'('fv')' { $$[0] = $2; $$[1] = $2; } | |||
| '('fv fv')' { $$[0] = $2; $$[1] = $3; } | |||
; | |||
v3: | |||
'('fv')' { $$[0] = $2; $$[1] = $2; $$[2] = $2; } | |||
| '('fv fv fv')' { $$[0] = $2; $$[1] = $3; $$[2] = $4; } | |||
; | |||
v4: | |||
'('fv')' { $$[0] = $2; $$[1] = $2; $$[2] = $2; $$[3] = $2; } | |||
| '('fv fv fv fv')' { $$[0] = $2; $$[1] = $3; $$[2] = $4; $$[3] = $5; } | |||
; | |||
/* Special types */ | |||
bv: | |||
BOOLEAN { $$ = $1; } | |||
| I_NUMBER { $$ = !!$1; } | |||
| F_NUMBER { $$ = !!$1; } | |||
; | |||
%% | |||
void lol::EasyMeshParser::error(const EasyMeshParser::location_type& l, | |||
const std::string& m) | |||
{ | |||
mc.Error(l, m); | |||
} | |||
@@ -1,208 +0,0 @@ | |||
%{ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net> | |||
// (c) 2009-2013 Cédric Lecacheur <jordx@free.fr> | |||
// (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com> | |||
// This program is free software; you can redistribute it and/or | |||
// modify it under the terms of the Do What The Fuck You Want To | |||
// Public License, Version 2, as published by Sam Hocevar. See | |||
// http://www.wtfpl.net/ for more details. | |||
// | |||
#if defined HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <cstdlib> | |||
using std::exit; | |||
using std::malloc; | |||
using std::realloc; | |||
using std::free; | |||
#include "core.h" | |||
#include "easymesh/easymesh-compiler.h" | |||
typedef lol::EasyMeshParser::token token; | |||
typedef lol::EasyMeshParser::token_type token_type; | |||
#ifndef YY_DECL | |||
# define YY_DECL lol::EasyMeshParser::token_type \ | |||
lol::EasyMeshScanner::lex(lol::EasyMeshParser::semantic_type* yylval, \ | |||
lol::EasyMeshParser::location_type* yylloc) | |||
#endif | |||
#define yyterminate() return token::T_END | |||
#define YY_NO_UNISTD_H | |||
#define YY_USER_ACTION yylloc->columns(yyleng); | |||
%} | |||
%option c++ prefix="EasyMesh" | |||
%option batch yywrap nounput stack | |||
%% | |||
%{ /* reset location at the beginning of yylex() */ | |||
yylloc->step(); | |||
%} | |||
(csgu|csgunion) { return token::T_CSGUNION; } | |||
(csgs|CsgSub) { return token::T_CSGSUBSTRACT; } | |||
(csgsl|CsgSubL) { return token::T_CSGSUBSTRACTLOSS; } | |||
(csga|csgand) { return token::T_CSGAND; } | |||
(csgx|csgxor) { return token::T_CSGXOR; } | |||
(lp|loop) { return token::T_LOOP; } | |||
(sc|setcolor) { return token::T_COLOR; } | |||
(sca|setcolora) { return token::T_ACOLOR; } | |||
(scb|setcolorb) { return token::T_BCOLOR; } | |||
(scv|setcolorv) { return token::T_VCOLOR; } | |||
(tsw|tglscalewind) { return token::T_TOGGLESCALEWINDING; } | |||
(tqw|tglquadweight) { return token::T_TOGGLEQUADWEIGHTING; } | |||
(tpbn|tglpstbuildnormal) { return token::T_TOGGLEPOSTBUILDNORMAL; } | |||
(tvnc|tglvertnocleanup) { return token::T_TOGGLEVERTNOCLEANUP; } | |||
(vm|vertmerge) { return token::T_VERTMERGE; } | |||
(vs|vertseparate) { return token::T_VERTSEPARATE; } | |||
(tx|translatex) { return token::T_TRANSLATEX; } | |||
(ty|translatey) { return token::T_TRANSLATEY; } | |||
(tz|translatez) { return token::T_TRANSLATEZ; } | |||
(t|translate) { return token::T_TRANSLATE; } | |||
(rx|rotatex) { return token::T_ROTATEX; } | |||
(ry|rotatey) { return token::T_ROTATEY; } | |||
(rz|rotatez) { return token::T_ROTATEZ; } | |||
(r|rotate) { return token::T_ROTATE; } | |||
(rj|radialjitter) { return token::T_RADIALJITTER; } | |||
(tax|taperx) { return token::T_TAPERX; } | |||
(tay|tapery) { return token::T_TAPERY; } | |||
(taz|taperz) { return token::T_TAPERZ; } | |||
(twx|twistx) { return token::T_TWISTX; } | |||
(twy|twisty) { return token::T_TWISTY; } | |||
(twz|twistz) { return token::T_TWISTZ; } | |||
(shx|shearx) { return token::T_SHEARX; } | |||
(shy|sheary) { return token::T_SHEARY; } | |||
(shz|shearz) { return token::T_SHEARZ; } | |||
(stx|stretchx) { return token::T_STRETCHX; } | |||
(sty|stretchy) { return token::T_STRETCHY; } | |||
(stz|stretchz) { return token::T_STRETCHZ; } | |||
(bdxy|bendxy) { return token::T_BENDXY; } | |||
(bdxz|bendxz) { return token::T_BENDXZ; } | |||
(bdyx|bendyx) { return token::T_BENDYX; } | |||
(bdyz|bendyz) { return token::T_BENDYZ; } | |||
(bdzx|bendzx) { return token::T_BENDZX; } | |||
(bdzy|bendzy) { return token::T_BENDZY; } | |||
(sx|scalex) { return token::T_SCALEX; } | |||
(sy|scaley) { return token::T_SCALEY; } | |||
(sz|scalez) { return token::T_SCALEZ; } | |||
(s|scale) { return token::T_SCALE; } | |||
(mx|mirrorx) { return token::T_MIRRORX; } | |||
(my|mirrory) { return token::T_MIRRORY; } | |||
(mz|mirrorz) { return token::T_MIRRORZ; } | |||
(ch|chamfer) { return token::T_CHAMFER; } | |||
(splt|splittriangle) { return token::T_SPLITTRIANGLE; } | |||
(smth|smooth) { return token::T_SMOOTHMESH; } | |||
(dup|duplicate) { return token::T_DUPLICATE; } | |||
(ac|addcylinder) { return token::T_CYLINDER; } | |||
(asph|addsphere) { return token::T_SPHERE; } | |||
(acap|addcapsule) { return token::T_CAPSULE; } | |||
(ato|addtorus) { return token::T_TORUS; } | |||
(ab|addbox) { return token::T_BOX; } | |||
(ascb|addsmoothchamfbox) { return token::T_SMOOTHCHAMFBOX; } | |||
(afcb|addflatchamfbox) { return token::T_FLATCHAMFBOX; } | |||
(as|addstar) { return token::T_STAR; } | |||
(aes|addexpandedstar) { return token::T_EXPANDEDSTAR; } | |||
(ad|adddisc) { return token::T_DISC; } | |||
(at|addtriangle) { return token::T_TRIANGLE; } | |||
(aq|addquad) { return token::T_QUAD; } | |||
(acg|addcog) { return token::T_COG; } | |||
%{ /* ======= BASE COLOR TYPES ========================================= */ %} | |||
%{ /* COLOR */ %} | |||
#[0-9a-fA-F]{3} { | |||
uint32_t tmp = std::strtol(yytext + 1, nullptr, 16); | |||
yylval->u32val = 0x11000000u * (tmp >> 8) | |||
| 0x00110000u * ((tmp >> 4) & 0xf) | |||
| 0x00001100u * (tmp & 0xf) | |||
| 0x000000ffu; | |||
return token::COLOR; } | |||
#[0-9a-fA-F]{4} { | |||
uint32_t tmp = std::strtol(yytext + 1, nullptr, 16); | |||
yylval->u32val = 0x11000000u * (tmp >> 12) | |||
| 0x00110000u * ((tmp >> 8) & 0xf) | |||
| 0x00001100u * ((tmp >> 4) & 0xf) | |||
| 0x00000011u * (tmp & 0xf); | |||
return token::COLOR; } | |||
#[0-9a-fA-F]{6} { | |||
yylval->u32val = 0xffu | |||
| 0x100u * (uint32_t)std::strtol(yytext + 1, nullptr, 16); | |||
return token::COLOR; } | |||
#[0-9a-fA-F]{8} { | |||
yylval->u32val = (uint32_t)std::strtol(yytext + 1, nullptr, 16); | |||
return token::COLOR; } | |||
%{ /* ======= BASE DATA TYPES ========================================= */ %} | |||
%{ /* BOOL */ %} | |||
true { yylval->bval = true; return token::BOOLEAN; } | |||
false { yylval->bval = false; return token::BOOLEAN; } | |||
%{ /* FLOAT */ %} | |||
[-+]?[0-9]*\.[0-9]+([eE][-+]?[0-9]+)? { | |||
yylval->fval = (float)std::atof(yytext); return token::F_NUMBER; } | |||
%{ /* INT */ %} | |||
[-+]?[0-9]+ { | |||
yylval->ival = std::atoi(yytext); return token::I_NUMBER; } | |||
%{ /* ======= COMMENTS ======= */ %} | |||
"//".* { /* ignore this */ } | |||
%{ /* Semantics tokens */ %} | |||
"-" { return token_type('-'); } | |||
"(" { return token_type('('); } | |||
")" { return token_type(')'); } | |||
"{" { return token_type('{'); } | |||
"}" { return token_type('}'); } | |||
[\[] { return token_type('['); } | |||
[\]] { return token_type(']'); } | |||
[ ,] { /* ignore this */ } | |||
[\n] { /* ignore this */ } | |||
. { return token::T_ERROR; } | |||
%% | |||
lol::EasyMeshScanner::EasyMeshScanner(char const *command) | |||
: EasyMeshFlexLexer(0, 0), | |||
m_input(command) | |||
{ | |||
} | |||
lol::EasyMeshScanner::~EasyMeshScanner() | |||
{ | |||
} | |||
int lol::EasyMeshScanner::LexerInput(char* buf, int max_size) | |||
{ | |||
(void)max_size; /* unused for now */ | |||
buf[0] = m_input[0]; | |||
if (buf[0]) | |||
++m_input; | |||
return buf[0] ? 1 : 0; | |||
} | |||
#ifdef yylex | |||
#undef yylex | |||
#endif | |||
int EasyMeshFlexLexer::yylex() | |||
{ | |||
std::cerr << "in EasyMeshFlexLexer::yylex() !" << std::endl; | |||
return 0; | |||
} | |||
int EasyMeshFlexLexer::yywrap() | |||
{ | |||
return 1; | |||
} | |||
@@ -1,799 +0,0 @@ | |||
%{ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright © 2012—2018 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if defined HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <cstdlib> | |||
using std::exit; | |||
using std::malloc; | |||
using std::realloc; | |||
using std::free; | |||
#include <iostream> | |||
#include <map> | |||
#include "core.h" | |||
#include "gpu/lolfx-compiler.h" | |||
typedef lol::LolFxParser::token token; | |||
typedef lol::LolFxParser::token_type token_type; | |||
#ifndef YY_DECL | |||
# define YY_DECL lol::LolFxParser::token_type \ | |||
lol::LolFxScanner::lex(lol::LolFxParser::semantic_type* yylval, \ | |||
lol::LolFxParser::location_type* yylloc) | |||
#endif | |||
#define yyterminate() return token::T_END | |||
#define YY_NO_UNISTD_H | |||
#define YY_USER_ACTION yylloc->columns(yyleng); | |||
%} | |||
%option c++ prefix="LolFx" | |||
%option batch yywrap nounput stack | |||
%x C_COMMENT | |||
%x CPP_COMMENT | |||
%x PREPROCESSOR_COMMENT | |||
%% | |||
%{ | |||
/* reset location at the beginning of yylex() */ | |||
yylloc->step(); | |||
int language_guess = INITIAL; | |||
m_pp_stack.Push(BlockIsTrue); | |||
%} | |||
/* | |||
* GLSL keywords | |||
*/ | |||
"subroutine" { return token::GT_SUBROUTINE; } | |||
"patch" { return token::GT_PATCH; } | |||
"sample" { return token::GT_SAMPLE; } | |||
"flat" { return token::GT_FLAT; } | |||
"smooth" { return token::GT_SMOOTH; } | |||
"layout" { return token::GT_LAYOUT; } | |||
"sampler1dshadow" { return token::GT_SAMPLER1DSHADOW; } | |||
"sampler2dshadow" { return token::GT_SAMPLER2DSHADOW; } | |||
"samplercubeshadow" { return token::GT_SAMPLERCUBESHADOW; } | |||
"sampler1darray" { return token::GT_SAMPLER1DARRAY; } | |||
"sampler2darray" { return token::GT_SAMPLER2DARRAY; } | |||
"sampler1darrayshadow" { return token::GT_SAMPLER1DARRAYSHADOW; } | |||
"sampler2darrayshadow" { return token::GT_SAMPLER2DARRAYSHADOW; } | |||
"isampler1d" { return token::GT_ISAMPLER1D; } | |||
"isampler2d" { return token::GT_ISAMPLER2D; } | |||
"isampler3d" { return token::GT_ISAMPLER3D; } | |||
"isamplercube" { return token::GT_ISAMPLERCUBE; } | |||
"isampler1darray" { return token::GT_ISAMPLER1DARRAY; } | |||
"isampler2darray" { return token::GT_ISAMPLER2DARRAY; } | |||
"usampler1d" { return token::GT_USAMPLER1D; } | |||
"usampler2d" { return token::GT_USAMPLER2D; } | |||
"usampler3d" { return token::GT_USAMPLER3D; } | |||
"usamplercube" { return token::GT_USAMPLERCUBE; } | |||
"usampler1darray" { return token::GT_USAMPLER1DARRAY; } | |||
"usampler2darray" { return token::GT_USAMPLER2DARRAY; } | |||
"sampler2drect" { return token::GT_SAMPLER2DRECT; } | |||
"sampler2drectshadow" { return token::GT_SAMPLER2DRECTSHADOW; } | |||
"isampler2drect" { return token::GT_ISAMPLER2DRECT; } | |||
"usampler2drect" { return token::GT_USAMPLER2DRECT; } | |||
"samplerbuffer" { return token::GT_SAMPLERBUFFER; } | |||
"isamplerbuffer" { return token::GT_ISAMPLERBUFFER; } | |||
"usamplerbuffer" { return token::GT_USAMPLERBUFFER; } | |||
"samplercubearray" { return token::GT_SAMPLERCUBEARRAY; } | |||
"samplercubearrayshadow" { return token::GT_SAMPLERCUBEARRAYSHADOW; } | |||
"isamplercubearray" { return token::GT_ISAMPLERCUBEARRAY; } | |||
"usamplercubearray" { return token::GT_USAMPLERCUBEARRAY; } | |||
"sampler2dms" { return token::GT_SAMPLER2DMS; } | |||
"isampler2dms" { return token::GT_ISAMPLER2DMS; } | |||
"usampler2dms" { return token::GT_USAMPLER2DMS; } | |||
"sampler2dmsarray" { return token::GT_SAMPLER2DMSARRAY; } | |||
"isampler2dmsarray" { return token::GT_ISAMPLER2DMSARRAY; } | |||
"usampler2dmsarray" { return token::GT_USAMPLER2DMSARRAY; } | |||
"highp" { return token::GT_HIGHP; } | |||
"mediump" { return token::GT_MEDIUMP; } | |||
"lowp" { return token::GT_LOWP; } | |||
"precision" { return token::GT_PRECISION; } | |||
"invariant" { return token::GT_INVARIANT; } | |||
/* | |||
* Deprecated GLSL keywords | |||
*/ | |||
"attribute" { return token::GT_ATTRIBUTE; } | |||
"varying" { return token::GT_VARYING; } | |||
/* | |||
* GLSL vector types | |||
*/ | |||
"bvec2" { return token::GT_BVEC2; } | |||
"bvec3" { return token::GT_BVEC3; } | |||
"bvec4" { return token::GT_BVEC4; } | |||
"ivec2" { return token::GT_IVEC2; } | |||
"ivec3" { return token::GT_IVEC3; } | |||
"ivec4" { return token::GT_IVEC4; } | |||
"uvec2" { return token::GT_UVEC2; } | |||
"uvec3" { return token::GT_UVEC3; } | |||
"uvec4" { return token::GT_UVEC4; } | |||
"vec2" { return token::GT_VEC2; } | |||
"vec3" { return token::GT_VEC3; } | |||
"vec4" { return token::GT_VEC4; } | |||
"mat2" { return token::GT_MAT2; } | |||
"mat2x2" { return token::GT_MAT2X2; } | |||
"mat2x3" { return token::GT_MAT2X3; } | |||
"mat2x4" { return token::GT_MAT2X4; } | |||
"mat3" { return token::GT_MAT3; } | |||
"mat3x2" { return token::GT_MAT3X2; } | |||
"mat3x3" { return token::GT_MAT3X3; } | |||
"mat3x4" { return token::GT_MAT3X4; } | |||
"mat4" { return token::GT_MAT4; } | |||
"mat4x2" { return token::GT_MAT4X2; } | |||
"mat4x3" { return token::GT_MAT4X3; } | |||
"mat4x4" { return token::GT_MAT4X4; } | |||
"dvec2" { return token::GT_DVEC2; } | |||
"dvec3" { return token::GT_DVEC3; } | |||
"dvec4" { return token::GT_DVEC4; } | |||
"dmat2" { return token::GT_DMAT2; } | |||
"dmat2x2" { return token::GT_DMAT2X2; } | |||
"dmat2x3" { return token::GT_DMAT2X3; } | |||
"dmat2x4" { return token::GT_DMAT2X4; } | |||
"dmat3" { return token::GT_DMAT3; } | |||
"dmat3x2" { return token::GT_DMAT3X2; } | |||
"dmat3x3" { return token::GT_DMAT3X3; } | |||
"dmat3x4" { return token::GT_DMAT3X4; } | |||
"dmat4" { return token::GT_DMAT4; } | |||
"dmat4x2" { return token::GT_DMAT4X2; } | |||
"dmat4x3" { return token::GT_DMAT4X3; } | |||
"dmat4x4" { return token::GT_DMAT4X4; } | |||
/* | |||
* GLSL constant values | |||
*/ | |||
"true" { yylval->ival = 1; return token::BOOLCONSTANT; } | |||
"false" { yylval->ival = 0; return token::BOOLCONSTANT; } | |||
/* | |||
* GLSL keywords that are also valid or reserved in HLSL | |||
* and HLSL keywords that are also valid or reserved in GLSL. | |||
*/ | |||
"bool" { return token::GHT_BOOL; } | |||
"break" { return token::GHT_BREAK; } | |||
"case" { return token::GHT_CASE; } | |||
"centroid" { return token::GHT_CENTROID; } | |||
"const" { return token::GHT_CONST; } | |||
"continue" { return token::GHT_CONTINUE; } | |||
"default" { return token::GHT_DEFAULT; } | |||
"discard" { return token::GHT_DISCARD; } | |||
"do" { return token::GHT_DO; } | |||
"double" { return token::GHT_DOUBLE; } | |||
"else" { return token::GHT_ELSE; } | |||
"float" { return token::GHT_FLOAT; } | |||
"for" { return token::GHT_FOR; } | |||
"if" { return token::GHT_IF; } | |||
"in" { return token::GHT_IN; } | |||
"inout" { return token::GHT_INOUT; } | |||
"int" { return token::GHT_INT; } | |||
"noperspective" { return token::GHT_NOPERSPECTIVE; } | |||
"out" { return token::GHT_OUT; } | |||
"return" { return token::GHT_RETURN; } | |||
"sampler1d" { return token::GHT_SAMPLER1D; } | |||
"sampler2d" { return token::GHT_SAMPLER2D; } | |||
"sampler3d" { return token::GHT_SAMPLER3D; } | |||
"samplercube" { return token::GHT_SAMPLERCUBE; } | |||
"struct" { return token::GHT_STRUCT; } | |||
"switch" { return token::GHT_SWITCH; } | |||
"uint" { return token::GHT_UINT; } | |||
"uniform" { return token::GHT_UNIFORM; } | |||
"void" { return token::GHT_VOID; } | |||
"while" { return token::GHT_WHILE; } | |||
(?i:bool) { return token::HGT_BOOL; } | |||
(?i:break) { return token::HGT_BREAK; } | |||
(?i:case) { return token::HGT_CASE; } | |||
(?i:centroid) { return token::HGT_CENTROID; } | |||
(?i:const) { return token::HGT_CONST; } | |||
(?i:continue) { return token::HGT_CONTINUE; } | |||
(?i:default) { return token::HGT_DEFAULT; } | |||
(?i:discard) { return token::HGT_DISCARD; } | |||
(?i:do) { return token::HGT_DO; } | |||
(?i:double) { return token::HGT_DOUBLE; } | |||
(?i:else) { return token::HGT_ELSE; } | |||
(?i:float) { return token::HGT_FLOAT; } | |||
(?i:for) { return token::HGT_FOR; } | |||
(?i:if) { return token::HGT_IF; } | |||
(?i:in) { return token::HGT_IN; } | |||
(?i:inout) { return token::HGT_INOUT; } | |||
(?i:int) { return token::HGT_INT; } | |||
(?i:noperspective) { return token::HGT_NOPERSPECTIVE; } | |||
(?i:out) { return token::HGT_OUT; } | |||
(?i:return) { return token::HGT_RETURN; } | |||
(?i:sampler1d) { return token::HGT_SAMPLER1D; } | |||
(?i:sampler2d) { return token::HGT_SAMPLER2D; } | |||
(?i:sampler3d) { return token::HGT_SAMPLER3D; } | |||
(?i:samplercube) { return token::HGT_SAMPLERCUBE; } | |||
(?i:struct) { return token::HGT_STRUCT; } | |||
(?i:switch) { return token::HGT_SWITCH; } | |||
(?i:uint) { return token::HGT_UINT; } | |||
(?i:uniform) { return token::HGT_UNIFORM; } | |||
(?i:void) { return token::HGT_VOID; } | |||
(?i:while) { return token::HGT_WHILE; } | |||
/* | |||
* HLSL keywords | |||
* Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509568%28v=vs.85%29.aspx | |||
*/ | |||
(?i:appendstructuredbuffer) { return token::HT_APPENDSTRUCTUREDBUFFER; } | |||
(?i:asm) { return token::HT_ASM; } | |||
(?i:asm_fragment) { return token::HT_ASM_FRAGMENT; } | |||
(?i:blendstate) { return token::HT_BLENDSTATE; } | |||
(?i:buffer) { return token::HT_BUFFER; } | |||
(?i:byteaddressbuffer) { return token::HT_BYTEADDRESSBUFFER; } | |||
(?i:cbuffer) { return token::HT_CBUFFER; } | |||
(?i:column_major) { return token::HT_COLUMN_MAJOR; } | |||
(?i:compile) { return token::HT_COMPILE; } | |||
(?i:compile_fragment) { return token::HT_COMPILE_FRAGMENT; } | |||
(?i:compileshader) { return token::HT_COMPILESHADER; } | |||
(?i:computeshader) { return token::HT_COMPUTESHADER; } | |||
(?i:consumestructuredbuffer) { return token::HT_CONSUMESTRUCTUREDBUFFER; } | |||
(?i:depthstencilstate) { return token::HT_DEPTHSTENCILSTATE; } | |||
(?i:depthstencilview) { return token::HT_DEPTHSTENCILVIEW; } | |||
(?i:domainshader) { return token::HT_DOMAINSHADER; } | |||
(?i:dword) { return token::HT_DWORD; } | |||
(?i:extern) { return token::HT_EXTERN; } | |||
(?i:false) { return token::HT_FALSE; } | |||
(?i:fxgroup) { return token::HT_FXGROUP; } | |||
(?i:geometryshader) { return token::HT_GEOMETRYSHADER; } | |||
(?i:groupshared) { return token::HT_GROUPSHARED; } | |||
(?i:half) { return token::HT_HALF; } | |||
(?i:hullshader) { return token::HT_HULLSHADER; } | |||
(?i:inline) { return token::HT_INLINE; } | |||
(?i:inputpatch) { return token::HT_INPUTPATCH; } | |||
(?i:interface) { return token::HT_INTERFACE; } | |||
(?i:line) { return token::HT_LINE; } | |||
(?i:lineadj) { return token::HT_LINEADJ; } | |||
(?i:linear) { return token::HT_LINEAR; } | |||
(?i:linestream) { return token::HT_LINESTREAM; } | |||
(?i:matrix) { return token::HT_MATRIX; } | |||
(?i:namespace) { return token::HT_NAMESPACE; } | |||
(?i:nointerpolation) { return token::HT_NOINTERPOLATION; } | |||
(?i:null) { return token::HT_NULL; } | |||
(?i:outputpatch) { return token::HT_OUTPUTPATCH; } | |||
(?i:packoffset) { return token::HT_PACKOFFSET; } | |||
(?i:pass) { return token::HT_PASS; } | |||
(?i:pixelfragment) { return token::HT_PIXELFRAGMENT; } | |||
(?i:pixelshader) { return token::HT_PIXELSHADER; } | |||
(?i:point) { return token::HT_POINT; } | |||
(?i:pointstream) { return token::HT_POINTSTREAM; } | |||
(?i:precise) { return token::HT_PRECISE; } | |||
(?i:rasterizerstate) { return token::HT_RASTERIZERSTATE; } | |||
(?i:rendertargetview) { return token::HT_RENDERTARGETVIEW; } | |||
(?i:register) { return token::HT_REGISTER; } | |||
(?i:row_major) { return token::HT_ROW_MAJOR; } | |||
(?i:rwbuffer) { return token::HT_RWBUFFER; } | |||
(?i:rwbyteaddressbuffer) { return token::HT_RWBYTEADDRESSBUFFER; } | |||
(?i:rwstructuredbuffer) { return token::HT_RWSTRUCTUREDBUFFER; } | |||
(?i:rwtexture1d) { return token::HT_RWTEXTURE1D; } | |||
(?i:rwtexture1darray) { return token::HT_RWTEXTURE1DARRAY; } | |||
(?i:rwtexture2d) { return token::HT_RWTEXTURE2D; } | |||
(?i:rwtexture2darray) { return token::HT_RWTEXTURE2DARRAY; } | |||
(?i:rwtexture3d) { return token::HT_RWTEXTURE3D; } | |||
(?i:sampler) { return token::HT_SAMPLER; } | |||
(?i:sampler_state) { return token::HT_SAMPLER_STATE; } | |||
(?i:samplerstate) { return token::HT_SAMPLERSTATE; } | |||
(?i:samplercomparisonstate) { return token::HT_SAMPLERCOMPARISONSTATE; } | |||
(?i:shared) { return token::HT_SHARED; } | |||
(?i:snorm) { return token::HT_SNORM; } | |||
(?i:stateblock) { return token::HT_STATEBLOCK; } | |||
(?i:stateblock_state) { return token::HT_STATEBLOCK_STATE; } | |||
(?i:static) { return token::HT_STATIC; } | |||
(?i:string) { return token::HT_STRING; } | |||
(?i:structuredbuffer) { return token::HT_STRUCTUREDBUFFER; } | |||
(?i:tbuffer) { return token::HT_TBUFFER; } | |||
(?i:technique) { return token::HT_TECHNIQUE; } | |||
(?i:technique10) { return token::HT_TECHNIQUE10; } | |||
(?i:technique11xz) { return token::HT_TECHNIQUE11XZ; } | |||
"texture" { return token::HT_TEXTURE; } | |||
(?i:texture1d) { return token::HT_TEXTURE1D; } | |||
(?i:texture1darray) { return token::HT_TEXTURE1DARRAY; } | |||
(?i:texture2d) { return token::HT_TEXTURE2D; } | |||
(?i:texture2darray) { return token::HT_TEXTURE2DARRAY; } | |||
(?i:texture2dms) { return token::HT_TEXTURE2DMS; } | |||
(?i:texture2dmsarray) { return token::HT_TEXTURE2DMSARRAY; } | |||
(?i:texture3d) { return token::HT_TEXTURE3D; } | |||
(?i:texturecube) { return token::HT_TEXTURECUBE; } | |||
(?i:texturecubearray) { return token::HT_TEXTURECUBEARRAY; } | |||
(?i:true) { return token::HT_TRUE; } | |||
(?i:typedef) { return token::HT_TYPEDEF; } | |||
(?i:triangle) { return token::HT_TRIANGLE; } | |||
(?i:triangleadj) { return token::HT_TRIANGLEADJ; } | |||
(?i:trianglestream) { return token::HT_TRIANGLESTREAM; } | |||
(?i:unorm) { return token::HT_UNORM; } | |||
(?i:vector) { return token::HT_VECTOR; } | |||
(?i:vertexfragment) { return token::HT_VERTEXFRAGMENT; } | |||
(?i:vertexshader) { return token::HT_VERTEXSHADER; } | |||
(?i:volatile) { return token::HT_VOLATILE; } | |||
/* | |||
* HLSL vector types | |||
* TODO: this can probably be factored somehow | |||
*/ | |||
(?i:bool1) { return token::HT_BOOL1; } | |||
(?i:bool1x1) { return token::HT_BOOL1x1; } | |||
(?i:bool2x1) { return token::HT_BOOL2x1; } | |||
(?i:bool3x1) { return token::HT_BOOL3x1; } | |||
(?i:bool4x1) { return token::HT_BOOL4x1; } | |||
(?i:bool2) { return token::HT_BOOL2; } | |||
(?i:bool1x2) { return token::HT_BOOL1x2; } | |||
(?i:bool2x2) { return token::HT_BOOL2x2; } | |||
(?i:bool3x2) { return token::HT_BOOL3x2; } | |||
(?i:bool4x2) { return token::HT_BOOL4x2; } | |||
(?i:bool3) { return token::HT_BOOL3; } | |||
(?i:bool1x3) { return token::HT_BOOL1x3; } | |||
(?i:bool2x3) { return token::HT_BOOL2x3; } | |||
(?i:bool3x3) { return token::HT_BOOL3x3; } | |||
(?i:bool4x3) { return token::HT_BOOL4x3; } | |||
(?i:bool4) { return token::HT_BOOL4; } | |||
(?i:bool1x4) { return token::HT_BOOL1x4; } | |||
(?i:bool2x4) { return token::HT_BOOL2x4; } | |||
(?i:bool3x4) { return token::HT_BOOL3x4; } | |||
(?i:bool4x4) { return token::HT_BOOL4x4; } | |||
(?i:float1) { return token::HT_FLOAT1; } | |||
(?i:float1x1) { return token::HT_FLOAT1x1; } | |||
(?i:float2x1) { return token::HT_FLOAT2x1; } | |||
(?i:float3x1) { return token::HT_FLOAT3x1; } | |||
(?i:float4x1) { return token::HT_FLOAT4x1; } | |||
(?i:float2) { return token::HT_FLOAT2; } | |||
(?i:float1x2) { return token::HT_FLOAT1x2; } | |||
(?i:float2x2) { return token::HT_FLOAT2x2; } | |||
(?i:float3x2) { return token::HT_FLOAT3x2; } | |||
(?i:float4x2) { return token::HT_FLOAT4x2; } | |||
(?i:float3) { return token::HT_FLOAT3; } | |||
(?i:float1x3) { return token::HT_FLOAT1x3; } | |||
(?i:float2x3) { return token::HT_FLOAT2x3; } | |||
(?i:float3x3) { return token::HT_FLOAT3x3; } | |||
(?i:float4x3) { return token::HT_FLOAT4x3; } | |||
(?i:float4) { return token::HT_FLOAT4; } | |||
(?i:float1x4) { return token::HT_FLOAT1x4; } | |||
(?i:float2x4) { return token::HT_FLOAT2x4; } | |||
(?i:float3x4) { return token::HT_FLOAT3x4; } | |||
(?i:float4x4) { return token::HT_FLOAT4x4; } | |||
(?i:double1) { return token::HT_DOUBLE1; } | |||
(?i:double1x1) { return token::HT_DOUBLE1x1; } | |||
(?i:double2x1) { return token::HT_DOUBLE2x1; } | |||
(?i:double3x1) { return token::HT_DOUBLE3x1; } | |||
(?i:double4x1) { return token::HT_DOUBLE4x1; } | |||
(?i:double2) { return token::HT_DOUBLE2; } | |||
(?i:double1x2) { return token::HT_DOUBLE1x2; } | |||
(?i:double2x2) { return token::HT_DOUBLE2x2; } | |||
(?i:double3x2) { return token::HT_DOUBLE3x2; } | |||
(?i:double4x2) { return token::HT_DOUBLE4x2; } | |||
(?i:double3) { return token::HT_DOUBLE3; } | |||
(?i:double1x3) { return token::HT_DOUBLE1x3; } | |||
(?i:double2x3) { return token::HT_DOUBLE2x3; } | |||
(?i:double3x3) { return token::HT_DOUBLE3x3; } | |||
(?i:double4x3) { return token::HT_DOUBLE4x3; } | |||
(?i:double4) { return token::HT_DOUBLE4; } | |||
(?i:double1x4) { return token::HT_DOUBLE1x4; } | |||
(?i:double2x4) { return token::HT_DOUBLE2x4; } | |||
(?i:double3x4) { return token::HT_DOUBLE3x4; } | |||
(?i:double4x4) { return token::HT_DOUBLE4x4; } | |||
(?i:dword1) { return token::HT_DWORD1; } | |||
(?i:dword1x1) { return token::HT_DWORD1x1; } | |||
(?i:dword2x1) { return token::HT_DWORD2x1; } | |||
(?i:dword3x1) { return token::HT_DWORD3x1; } | |||
(?i:dword4x1) { return token::HT_DWORD4x1; } | |||
(?i:dword2) { return token::HT_DWORD2; } | |||
(?i:dword1x2) { return token::HT_DWORD1x2; } | |||
(?i:dword2x2) { return token::HT_DWORD2x2; } | |||
(?i:dword3x2) { return token::HT_DWORD3x2; } | |||
(?i:dword4x2) { return token::HT_DWORD4x2; } | |||
(?i:dword3) { return token::HT_DWORD3; } | |||
(?i:dword1x3) { return token::HT_DWORD1x3; } | |||
(?i:dword2x3) { return token::HT_DWORD2x3; } | |||
(?i:dword3x3) { return token::HT_DWORD3x3; } | |||
(?i:dword4x3) { return token::HT_DWORD4x3; } | |||
(?i:dword4) { return token::HT_DWORD4; } | |||
(?i:dword1x4) { return token::HT_DWORD1x4; } | |||
(?i:dword2x4) { return token::HT_DWORD2x4; } | |||
(?i:dword3x4) { return token::HT_DWORD3x4; } | |||
(?i:dword4x4) { return token::HT_DWORD4x4; } | |||
(?i:int1) { return token::HT_INT1; } | |||
(?i:int1x1) { return token::HT_INT1x1; } | |||
(?i:int2x1) { return token::HT_INT2x1; } | |||
(?i:int3x1) { return token::HT_INT3x1; } | |||
(?i:int4x1) { return token::HT_INT4x1; } | |||
(?i:int2) { return token::HT_INT2; } | |||
(?i:int1x2) { return token::HT_INT1x2; } | |||
(?i:int2x2) { return token::HT_INT2x2; } | |||
(?i:int3x2) { return token::HT_INT3x2; } | |||
(?i:int4x2) { return token::HT_INT4x2; } | |||
(?i:int3) { return token::HT_INT3; } | |||
(?i:int1x3) { return token::HT_INT1x3; } | |||
(?i:int2x3) { return token::HT_INT2x3; } | |||
(?i:int3x3) { return token::HT_INT3x3; } | |||
(?i:int4x3) { return token::HT_INT4x3; } | |||
(?i:int4) { return token::HT_INT4; } | |||
(?i:int1x4) { return token::HT_INT1x4; } | |||
(?i:int2x4) { return token::HT_INT2x4; } | |||
(?i:int3x4) { return token::HT_INT3x4; } | |||
(?i:int4x4) { return token::HT_INT4x4; } | |||
(?i:uint1) { return token::HT_UINT1; } | |||
(?i:uint1x1) { return token::HT_UINT1x1; } | |||
(?i:uint2x1) { return token::HT_UINT2x1; } | |||
(?i:uint3x1) { return token::HT_UINT3x1; } | |||
(?i:uint4x1) { return token::HT_UINT4x1; } | |||
(?i:uint2) { return token::HT_UINT2; } | |||
(?i:uint1x2) { return token::HT_UINT1x2; } | |||
(?i:uint2x2) { return token::HT_UINT2x2; } | |||
(?i:uint3x2) { return token::HT_UINT3x2; } | |||
(?i:uint4x2) { return token::HT_UINT4x2; } | |||
(?i:uint3) { return token::HT_UINT3; } | |||
(?i:uint1x3) { return token::HT_UINT1x3; } | |||
(?i:uint2x3) { return token::HT_UINT2x3; } | |||
(?i:uint3x3) { return token::HT_UINT3x3; } | |||
(?i:uint4x3) { return token::HT_UINT4x3; } | |||
(?i:uint4) { return token::HT_UINT4; } | |||
(?i:uint1x4) { return token::HT_UINT1x4; } | |||
(?i:uint2x4) { return token::HT_UINT2x4; } | |||
(?i:uint3x4) { return token::HT_UINT3x4; } | |||
(?i:uint4x4) { return token::HT_UINT4x4; } | |||
/* | |||
* HLSL preprocessor directives | |||
* Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb943993%28v=vs.85%29.aspx | |||
*/ | |||
^[ \t]*"#"[ \t]*"define".* { | |||
/* FIXME: this is very, very limited */ | |||
char const *tmp = strstr(yytext, "define") + 6; | |||
while (*tmp == ' ' || *tmp == '\n') | |||
tmp++; | |||
if (*tmp == '\0') | |||
return token::PREPROCESSOR_DEFINE; | |||
char const *tmp2 = tmp; | |||
while (*tmp != ' ' && *tmp != '\n' && *tmp != '\0') | |||
tmp++; | |||
String key(tmp2, (int)(tmp - tmp2)); | |||
while (*tmp == ' ' || *tmp == '\n') | |||
tmp++; | |||
String val(*tmp ? tmp : "1"); | |||
Log::Debug("new macro: ‘%s’ = ‘%s’\n", key.C(), val.C()); | |||
m_pp_defines[key] = val; | |||
} | |||
^[ \t]*"#"[ \t]*"elif" { | |||
if (m_pp_stack.Count() <= 1) | |||
return token::PREPROCESSOR_ELIF; | |||
m_pp_stack.Last() = BlockIsForeverFalse; | |||
BEGIN(PREPROCESSOR_COMMENT); | |||
} | |||
^[ \t]*"#"[ \t]*"else" { | |||
if (m_pp_stack.Count() <= 1) | |||
return token::PREPROCESSOR_ELSE; | |||
m_pp_stack.Last() = BlockIsForeverFalse; | |||
BEGIN(PREPROCESSOR_COMMENT); | |||
} | |||
^[ \t]*"#"[ \t]*"endif" { | |||
if (m_pp_stack.Count() <= 1) | |||
return token::PREPROCESSOR_ENDIF; | |||
m_pp_stack.Pop(); | |||
} | |||
^[ \t]*"#"[ \t]*"error".* { return token::PREPROCESSOR_ERROR; } | |||
^[ \t]*"#"[ \t]*"if".* { | |||
if (IsExpressionTrue(strstr(yytext, "if") + 2)) | |||
{ | |||
m_pp_stack.Push(BlockIsTrue); | |||
} | |||
else | |||
{ | |||
m_pp_stack.Push(BlockIsFalse); | |||
BEGIN(PREPROCESSOR_COMMENT); | |||
} | |||
} | |||
^[ \t]*"#"[ \t]*"ifdef" { | |||
/* FIXME: this is very, very limited */ | |||
char const *tmp = strstr(yytext, "ifdef") + 5; | |||
while (*tmp == ' ' || *tmp == '\n') | |||
tmp++; | |||
if (*tmp == '\0') | |||
return token::PREPROCESSOR_IFDEF; | |||
char const *tmp2 = tmp; | |||
while (*tmp != ' ' && *tmp != '\n' && *tmp != '\0') | |||
tmp++; | |||
String key(tmp2, (int)(tmp - tmp2)); | |||
if (has_key(m_pp_defines, key)) | |||
{ | |||
m_pp_stack.Push(BlockIsTrue); | |||
} | |||
else | |||
{ | |||
m_pp_stack.Push(BlockIsFalse); | |||
BEGIN(PREPROCESSOR_COMMENT); | |||
} | |||
} | |||
^[ \t]*"#"[ \t]*"ifndef" { | |||
/* FIXME: this is very, very limited */ | |||
char const *tmp = strstr(yytext, "ifndef") + 6; | |||
while (*tmp == ' ' || *tmp == '\n') | |||
tmp++; | |||
if (*tmp == '\0') | |||
return token::PREPROCESSOR_IFDEF; | |||
char const *tmp2 = tmp; | |||
while (*tmp != ' ' && *tmp != '\n' && *tmp != '\0') | |||
tmp++; | |||
String key(tmp2, (int)(tmp - tmp2)); | |||
if (has_key(m_pp_defines, key)) | |||
{ | |||
m_pp_stack.Push(BlockIsFalse); | |||
BEGIN(PREPROCESSOR_COMMENT); | |||
} | |||
else | |||
{ | |||
m_pp_stack.Push(BlockIsTrue); | |||
} | |||
} | |||
^[ \t]*"#"[ \t]*"include" { return token::PREPROCESSOR_INCLUDE; } | |||
^[ \t]*"#"[ \t]*"line".* { /* ignore for now */ } | |||
^[ \t]*"#"[ \t]*"pragma".* { /* ignore for now */ } | |||
^[ \t]*"#"[ \t]*"undef" { | |||
/* FIXME: this is very, very limited */ | |||
char const *tmp = strstr(yytext, "undef") + 5; | |||
while (*tmp == ' ' || *tmp == '\n') | |||
tmp++; | |||
if (*tmp == '\0') | |||
return token::PREPROCESSOR_UNDEF; | |||
char const *tmp2 = tmp; | |||
while (*tmp != ' ' && *tmp != '\n' && *tmp != '\0') | |||
tmp++; | |||
String key(tmp2, (int)(tmp - tmp2)); | |||
Log::Debug("undef macro: ‘%s’\n", key.C()); | |||
m_pp_defines.remove(key); | |||
} | |||
<PREPROCESSOR_COMMENT>^[ \t]*"#"[ \t]*(if|ifdef|ifndef)[ \t]+.*$ { | |||
m_pp_stack.Push(BlockIsForeverFalse); | |||
} | |||
<PREPROCESSOR_COMMENT>^[ \t]*"#"[ \t]*"else" { | |||
switch (m_pp_stack.Last()) | |||
{ | |||
case BlockIsFalse: | |||
m_pp_stack.Last() = BlockIsTrue; | |||
BEGIN(INITIAL); | |||
break; | |||
case BlockIsForeverFalse: | |||
break; | |||
case BlockIsTrue: | |||
m_pp_stack.Last() = BlockIsForeverFalse; | |||
break; | |||
} | |||
} | |||
<PREPROCESSOR_COMMENT>^[ \t]*"#"[ \t]*"elif" { | |||
switch (m_pp_stack.Last()) | |||
{ | |||
case BlockIsFalse: | |||
if (IsExpressionTrue(strstr(yytext, "elif") + 4)) | |||
{ | |||
m_pp_stack.Last() = BlockIsTrue; | |||
BEGIN(INITIAL); | |||
} | |||
break; | |||
case BlockIsForeverFalse: | |||
break; | |||
case BlockIsTrue: | |||
m_pp_stack.Last() = BlockIsForeverFalse; | |||
break; | |||
} | |||
} | |||
<PREPROCESSOR_COMMENT>^[ \t]*"#"[ \t]*"endif" { | |||
m_pp_stack.Pop(); | |||
if (m_pp_stack.Last() == BlockIsTrue) | |||
BEGIN(INITIAL); | |||
} | |||
<PREPROCESSOR_COMMENT>\n { yylloc->lines(1); } | |||
<PREPROCESSOR_COMMENT>[^/#]* { } | |||
<PREPROCESSOR_COMMENT>"/*" { BEGIN(C_COMMENT); } | |||
<PREPROCESSOR_COMMENT>[/#] { } | |||
/* | |||
* GLSL preprocessor directives | |||
*/ | |||
^[ \t]*"#"[ \t]*"version"[^\n]* { /* ignore for now */ } | |||
/* | |||
* HLSL reserved keywords | |||
* Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509569%28v=vs.85%29.aspx | |||
*/ | |||
(?i:auto) { return token::HT_AUTO; } | |||
(?i:catch) { return token::HT_CATCH; } | |||
(?i:char) { return token::HT_CHAR; } | |||
(?i:class) { return token::HT_CLASS; } | |||
(?i:const_cast) { return token::HT_CONST_CAST; } | |||
(?i:delete) { return token::HT_DELETE; } | |||
(?i:dynamic_cast) { return token::HT_DYNAMIC_CAST; } | |||
(?i:enum) { return token::HT_ENUM; } | |||
(?i:explicit) { return token::HT_EXPLICIT; } | |||
(?i:friend) { return token::HT_FRIEND; } | |||
(?i:goto) { return token::HT_GOTO; } | |||
(?i:long) { return token::HT_LONG; } | |||
(?i:mutable) { return token::HT_MUTABLE; } | |||
(?i:new) { return token::HT_NEW; } | |||
(?i:operator) { return token::HT_OPERATOR; } | |||
(?i:private) { return token::HT_PRIVATE; } | |||
(?i:protected) { return token::HT_PROTECTED; } | |||
(?i:public) { return token::HT_PUBLIC; } | |||
(?i:reinterpret_cast) { return token::HT_REINTERPRET_CAST; } | |||
(?i:short) { return token::HT_SHORT; } | |||
(?i:signed) { return token::HT_SIGNED; } | |||
(?i:sizeof) { return token::HT_SIZEOF; } | |||
(?i:static_cast) { return token::HT_STATIC_CAST; } | |||
(?i:template) { return token::HT_TEMPLATE; } | |||
(?i:this) { return token::HT_THIS; } | |||
(?i:throw) { return token::HT_THROW; } | |||
(?i:try) { return token::HT_TRY; } | |||
(?i:typename) { return token::HT_TYPENAME; } | |||
(?i:union) { return token::HT_UNION; } | |||
(?i:unsigned) { return token::HT_UNSIGNED; } | |||
(?i:using) { return token::HT_USING; } | |||
(?i:virtual) { return token::HT_VIRTUAL; } | |||
/* | |||
* Various tokens | |||
*/ | |||
"++" { return token::T_INC; } | |||
"--" { return token::T_DEC; } | |||
"<=" { return token::T_LE; } | |||
">=" { return token::T_GE; } | |||
"==" { return token::T_EQ; } | |||
"!=" { return token::T_NE; } | |||
"<<" { return token::T_LEFT; } | |||
">>" { return token::T_RIGHT; } | |||
"&&" { return token::T_AND; } | |||
"||" { return token::T_OR; } | |||
"^^" { return token::T_XOR; } | |||
"*=" { return token::T_MULEQ; } | |||
"/=" { return token::T_DIVEQ; } | |||
"%=" { return token::T_MODEQ; } | |||
"+=" { return token::T_ADDEQ; } | |||
"-=" { return token::T_SUBEQ; } | |||
"<<=" { return token::T_LEFTEQ; } | |||
">>=" { return token::T_RIGHTEQ; } | |||
"&=" { return token::T_ANDEQ; } | |||
"^=" { return token::T_XOREQ; } | |||
"|=" { return token::T_OREQ; } | |||
(0|[1-9][0-9]*)\.[0-9]+ { | |||
yylval->fval = std::atof(yytext); | |||
return token::FLOATCONSTANT; | |||
} | |||
(0|[1-9][0-9]*)[uU] { | |||
yylval->uval = std::atoi(yytext); | |||
return token::UINTCONSTANT; | |||
} | |||
(0|[1-9][0-9]*) { | |||
yylval->ival = std::atoi(yytext); | |||
return token::INTCONSTANT; | |||
} | |||
([xyzw]{1,4}|[rgba]{1,4}|[stpq]{1,4}) { | |||
/* Copy token for now */ | |||
yylval->sval = strdup(yytext); | |||
return token::FIELDSELECTION; | |||
} | |||
[a-zA-Z_][a-zA-Z0-9_]* { | |||
/* Copy token for now */ | |||
yylval->sval = strdup(yytext); | |||
return token::IDENTIFIER; | |||
} | |||
[ \t\r]+ { /* ignore whitespace */ } | |||
[\n] { yylloc->lines(1); } | |||
. { return (token_type)*yytext; /* accept all characters */ } | |||
/* | |||
* Ignore C comments | |||
*/ | |||
"/*" { BEGIN(C_COMMENT); } | |||
<C_COMMENT>[^*\n]* { } | |||
<C_COMMENT>\n { yylloc->lines(1); } | |||
<C_COMMENT>. { } | |||
<C_COMMENT>"*/" { | |||
if (m_pp_stack.Last() == BlockIsTrue) | |||
BEGIN(INITIAL); | |||
else | |||
BEGIN(PREPROCESSOR_COMMENT); | |||
} | |||
/* | |||
* Ignore C++ comments | |||
*/ | |||
"//" { BEGIN(CPP_COMMENT); } | |||
<CPP_COMMENT>\n { yylloc->lines(1); BEGIN(INITIAL); } | |||
<CPP_COMMENT>.* { } | |||
%% | |||
lol::LolFxScanner::LolFxScanner(char const *command) | |||
: LolFxFlexLexer(0, 0), | |||
m_input(command) | |||
{ | |||
} | |||
lol::LolFxScanner::~LolFxScanner() | |||
{ | |||
} | |||
int lol::LolFxScanner::LexerInput(char* buf, int max_size) | |||
{ | |||
buf[0] = m_input[0]; | |||
if (buf[0]) | |||
++m_input; | |||
return buf[0] ? 1 : 0; | |||
} | |||
bool lol::LolFxScanner::IsExpressionTrue(char const *buf) | |||
{ | |||
/* FIXME: this is really too limited */ | |||
return std::atoi(buf) != 0; | |||
} | |||
#ifdef yylex | |||
#undef yylex | |||
#endif | |||
int LolFxFlexLexer::yylex() | |||
{ | |||
std::cerr << "in LolFxFlexLexer::yylex() !" << std::endl; | |||
return 0; | |||
} | |||
int LolFxFlexLexer::yywrap() | |||
{ | |||
return 1; | |||
} | |||
@@ -1,8 +0,0 @@ | |||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> | |||
<html> | |||
<head> | |||
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> | |||
<title>lolengine documentation</title> | |||
<link href="doxygen.css" rel="stylesheet" type="text/css"> | |||
</head> | |||
<body> |
@@ -1,10 +0,0 @@ | |||
.TH lolengine 1 "2012-01-01" "lolengine" | |||
.SH NAME | |||
lolengine\- foo bar | |||
.SH SYNOPSIS | |||
.B lolengine | |||
[ | |||
.B \--crash | |||
.I activated by default | |||
] | |||
@@ -1,18 +0,0 @@ | |||
/** \mainpage lolengine Documentation | |||
\section intro Introduction | |||
\e lolengine | |||
\e lolengine is free software, released under the Do What The Fuck You | |||
Want To Public License. This ensures that no one, not even \e lolengine | |||
developers, will ever have anything to say about what you do with the | |||
software. | |||
\section license License | |||
Permission is granted to copy, distribute and/or modify this document | |||
under the terms of the Do What The Fuck You Want To Public License, version | |||
2 as published by Sam Hocevar. For details see http://www.wtfpl.net/ . | |||
*/ |
@@ -1,48 +0,0 @@ | |||
include $(top_srcdir)/build/autotools/common.am | |||
SUBDIRS = math sandbox | |||
bench: benchsuite$(EXEEXT) | |||
./benchsuite$(EXEEXT) | |||
if BUILD_SAMPLES | |||
noinst_PROGRAMS = bluenoise benchsuite simplex | |||
if LOL_USE_GL | |||
if LOL_USE_BULLET | |||
noinst_PROGRAMS += btphystest | |||
endif | |||
endif | |||
endif | |||
bluenoise_SOURCES = bluenoise.cpp | |||
bluenoise_CPPFLAGS = $(AM_CPPFLAGS) | |||
bluenoise_DEPENDENCIES = @LOL_DEPS@ | |||
benchsuite_SOURCES = benchsuite.cpp \ | |||
benchmark/vector.cpp benchmark/half.cpp benchmark/real.cpp | |||
benchsuite_CPPFLAGS = $(AM_CPPFLAGS) | |||
benchsuite_DEPENDENCIES = @LOL_DEPS@ | |||
btphystest_SOURCES = \ | |||
btphystest.cpp btphystest.h physicobject.h \ | |||
physics/easyphysics.cpp physics/easyphysics.h \ | |||
physics/lolbtphysicsintegration.h physics/lolphysics.h \ | |||
physics/easycharactercontroller.cpp physics/easycharactercontroller.h \ | |||
physics/easyconstraint.cpp physics/easyconstraint.h \ | |||
physics/bulletcharactercontroller.cpp physics/bulletcharactercontroller.h \ | |||
\ | |||
front_camera_sprite.lolfx | |||
btphystest_CPPFLAGS = $(AM_CPPFLAGS) | |||
btphystest_DEPENDENCIES = @LOL_DEPS@ | |||
btphystest_LDFLAGS = $(AM_LDFLAGS) | |||
if LOL_USE_EMSCRIPTEN | |||
btphystest_LDFLAGS += \ | |||
--preload-file data/CatsSheet.png \ | |||
-s TOTAL_MEMORY=$(shell expr 32 '*' 1024 '*' 1024) | |||
endif | |||
simplex_SOURCES = simplex.cpp | |||
simplex_CPPFLAGS = $(AM_CPPFLAGS) | |||
simplex_DEPENDENCIES = @LOL_DEPS@ | |||
@@ -1,127 +0,0 @@ | |||
// | |||
// Lol Engine — Benchmark program | |||
// | |||
// Copyright © 2005—2018 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// This program is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <cstdio> | |||
#include <lol/engine.h> | |||
using namespace lol; | |||
static size_t const HALF_TABLE_SIZE = 1024 * 1024; | |||
static size_t const HALF_RUNS = 50; | |||
void bench_half(int mode) | |||
{ | |||
float result[10] = { 0.0f }; | |||
lol::timer timer; | |||
/* Set up tables */ | |||
float *pf = new float[HALF_TABLE_SIZE + 1]; | |||
half *ph = new half[HALF_TABLE_SIZE + 1]; | |||
for (size_t run = 0; run < HALF_RUNS; run++) | |||
{ | |||
switch (mode) | |||
{ | |||
case 1: | |||
for (size_t i = 0; i < HALF_TABLE_SIZE + 1; i++) | |||
ph[i] = half::makebits(rand<uint16_t>()); | |||
break; | |||
case 2: | |||
default: | |||
for (size_t i = 0; i < HALF_TABLE_SIZE + 1; i++) | |||
ph[i] = rand(-2.0f, 2.0f); | |||
break; | |||
} | |||
/* Convert half to float (array) */ | |||
timer.get(); | |||
half::convert(pf, ph, HALF_TABLE_SIZE); | |||
result[0] += timer.get(); | |||
/* Convert half to float (fast) */ | |||
timer.get(); | |||
for (size_t i = 0; i < HALF_TABLE_SIZE; i++) | |||
pf[i] = (float)ph[i]; | |||
result[1] += timer.get(); | |||
/* Copy float */ | |||
timer.get(); | |||
for (size_t i = 0; i < HALF_TABLE_SIZE; i++) | |||
pf[i] = pf[i + 1]; | |||
result[2] += timer.get(); | |||
/* Add a half to every float */ | |||
timer.get(); | |||
for (size_t i = 0; i < HALF_TABLE_SIZE; i++) | |||
pf[i] += ph[i]; | |||
result[3] += timer.get(); | |||
/* Copy half */ | |||
timer.get(); | |||
for (size_t i = 0; i < HALF_TABLE_SIZE; i++) | |||
ph[i] = ph[i + 1]; | |||
result[4] += timer.get(); | |||
/* Change sign of every half */ | |||
timer.get(); | |||
for (size_t i = 0; i < HALF_TABLE_SIZE; i++) | |||
ph[i] = -ph[i]; | |||
result[5] += timer.get(); | |||
/* Convert float to half (array) */ | |||
timer.get(); | |||
half::convert(ph, pf, HALF_TABLE_SIZE); | |||
result[6] += timer.get(); | |||
/* Convert float to half (fast) */ | |||
timer.get(); | |||
for (size_t i = 0; i < HALF_TABLE_SIZE; i++) | |||
ph[i] = (half)pf[i]; | |||
result[7] += timer.get(); | |||
/* Convert float to half (accurate) */ | |||
timer.get(); | |||
for (size_t i = 0; i < HALF_TABLE_SIZE; i++) | |||
ph[i] = half::makeaccurate(pf[i]); | |||
result[8] += timer.get(); | |||
/* Add a float to every half */ | |||
timer.get(); | |||
for (size_t i = 0; i < HALF_TABLE_SIZE; i++) | |||
ph[i] += pf[i]; | |||
result[9] += timer.get(); | |||
} | |||
delete[] pf; | |||
delete[] ph; | |||
for (size_t i = 0; i < sizeof(result) / sizeof(*result); i++) | |||
result[i] *= 1e9f / (HALF_TABLE_SIZE * HALF_RUNS); | |||
msg::info(" ns/elem\n"); | |||
msg::info("float = half (array) %7.3f\n", result[0]); | |||
msg::info("float = half (fast) %7.3f\n", result[1]); | |||
msg::info("float = float %7.3f\n", result[2]); | |||
msg::info("float += half %7.3f\n", result[3]); | |||
msg::info("half = half %7.3f\n", result[4]); | |||
msg::info("half = -half %7.3f\n", result[5]); | |||
msg::info("half = float (array) %7.3f\n", result[6]); | |||
msg::info("half = float (fast) %7.3f\n", result[7]); | |||
msg::info("half = float (accurate) %7.3f\n", result[8]); | |||
msg::info("half += float %7.3f\n", result[9]); | |||
} | |||
@@ -1,82 +0,0 @@ | |||
// | |||
// Lol Engine — Benchmark program | |||
// | |||
// Copyright © 2005—2018 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// This program is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <cstdio> | |||
#include <lol/engine.h> | |||
using namespace lol; | |||
static size_t const REAL_TABLE_SIZE = 10000; | |||
static size_t const REAL_RUNS = 50; | |||
void bench_real(int mode) | |||
{ | |||
float result[12] = { 0.0f }; | |||
lol::timer timer; | |||
for (size_t run = 0; run < REAL_RUNS; run++) | |||
{ | |||
switch (mode) | |||
{ | |||
case 1: | |||
break; | |||
} | |||
real fib1 = 1.0, fib2 = 1.0; | |||
timer.get(); | |||
for (size_t i = 0; i < REAL_TABLE_SIZE; i++) | |||
{ | |||
real tmp = fib1 + fib2; | |||
fib1 = fib2; | |||
fib2 = tmp; | |||
} | |||
result[0] += timer.get(); | |||
real fact = 1.0; | |||
timer.get(); | |||
for (size_t i = 0; i < REAL_TABLE_SIZE; i++) | |||
fact = fact * real(1.0 + i); | |||
result[1] += timer.get(); | |||
real invfact = 1.0; | |||
timer.get(); | |||
for (size_t i = 0; i < REAL_TABLE_SIZE; i++) | |||
invfact = invfact / real(1.0 + i); | |||
result[2] += timer.get(); | |||
timer.get(); | |||
for (size_t i = 0; i < REAL_TABLE_SIZE / 128; i++) | |||
(void)sin(real(0.01 * i)); | |||
result[3] += timer.get() * 128; | |||
timer.get(); | |||
for (size_t i = 0; i < REAL_TABLE_SIZE / 128; i++) | |||
(void)exp((real)(int)(i - REAL_TABLE_SIZE / 256)); | |||
result[4] += timer.get() * 128; | |||
} | |||
for (size_t i = 0; i < sizeof(result) / sizeof(*result); i++) | |||
result[i] *= 1e9f / (REAL_TABLE_SIZE * REAL_RUNS); | |||
msg::info(" ns/elem\n"); | |||
msg::info("real = real + real %7.3f\n", result[0]); | |||
msg::info("real = real * real %7.3f\n", result[1]); | |||
msg::info("real = real / real %7.3f\n", result[2]); | |||
msg::info("real = sin(real) %7.3f\n", result[3]); | |||
msg::info("real = exp(real) %7.3f\n", result[4]); | |||
} | |||
@@ -1,91 +0,0 @@ | |||
// | |||
// Lol Engine — Benchmark program | |||
// | |||
// Copyright © 2005—2018 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// This program is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <cstdio> | |||
#include <lol/engine.h> | |||
using namespace lol; | |||
static size_t const MATRIX_TABLE_SIZE = 64 * 1024; | |||
static size_t const MATRIX_RUNS = 100; | |||
void bench_matrix(int mode) | |||
{ | |||
float result[5] = { 0.0f }; | |||
lol::timer timer; | |||
/* Set up tables */ | |||
mat4 *pm = new mat4[MATRIX_TABLE_SIZE + 1]; | |||
float *pf = new float[MATRIX_TABLE_SIZE]; | |||
for (size_t run = 0; run < MATRIX_RUNS; run++) | |||
{ | |||
switch (mode) | |||
{ | |||
case 1: | |||
for (size_t i = 0; i < MATRIX_TABLE_SIZE; i++) | |||
for (int j = 0; j < 4; j++) | |||
for (int k = 0; k < 4; k++) | |||
pm[i][j][k] = rand(-2.0f, 2.0f); | |||
break; | |||
} | |||
/* Copy matrices */ | |||
timer.get(); | |||
for (size_t i = 0; i < MATRIX_TABLE_SIZE; i++) | |||
pm[i] = pm[i + 1]; | |||
result[0] += timer.get(); | |||
/* Determinant */ | |||
timer.get(); | |||
for (size_t i = 0; i < MATRIX_TABLE_SIZE; i++) | |||
pf[i] = determinant(pm[i]); | |||
result[1] += timer.get(); | |||
/* Multiply matrices */ | |||
timer.get(); | |||
for (size_t i = 0; i < MATRIX_TABLE_SIZE; i++) | |||
pm[i] *= pm[i + 1]; | |||
result[2] += timer.get(); | |||
/* Add matrices */ | |||
timer.get(); | |||
for (size_t i = 0; i < MATRIX_TABLE_SIZE; i++) | |||
pm[i] += pm[i + 1]; | |||
result[3] += timer.get(); | |||
/* Invert matrix */ | |||
timer.get(); | |||
for (size_t i = 0; i < MATRIX_TABLE_SIZE; i++) | |||
pm[i] = inverse(pm[i]); | |||
result[4] += timer.get(); | |||
} | |||
delete[] pm; | |||
delete[] pf; | |||
for (size_t i = 0; i < sizeof(result) / sizeof(*result); i++) | |||
result[i] *= 1e9f / (MATRIX_TABLE_SIZE * MATRIX_RUNS); | |||
msg::info(" ns/elem\n"); | |||
msg::info("mat4 = mat4 %7.3f\n", result[0]); | |||
msg::info("float = mat4.det() %7.3f\n", result[1]); | |||
msg::info("mat4 *= mat4 %7.3f\n", result[2]); | |||
msg::info("mat4 += mat4 %7.3f\n", result[3]); | |||
msg::info("mat4 = mat4.invert() %7.3f\n", result[4]); | |||
} | |||
@@ -1,57 +0,0 @@ | |||
// | |||
// Lol Engine — Benchmark program | |||
// | |||
// Copyright © 2005—2015 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// This program is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <cstdio> | |||
#include <lol/engine.h> | |||
using namespace lol; | |||
void bench_real(int mode); | |||
void bench_matrix(int mode); | |||
void bench_half(int mode); | |||
int main(int argc, char **argv) | |||
{ | |||
UNUSED(argc, argv); | |||
msg::info("-----------------------\n"); | |||
msg::info(" High precision floats\n"); | |||
msg::info("-----------------------\n"); | |||
bench_real(1); | |||
msg::info("----------------------------\n"); | |||
msg::info(" Float matrices [-2.0, 2.0]\n"); | |||
msg::info("----------------------------\n"); | |||
bench_matrix(1); | |||
msg::info("-------------------------------------\n"); | |||
msg::info(" Half precision floats (random bits)\n"); | |||
msg::info("-------------------------------------\n"); | |||
bench_half(1); | |||
msg::info("-----------------------------------\n"); | |||
msg::info(" Half precision floats [-2.0, 2.0]\n"); | |||
msg::info("-----------------------------------\n"); | |||
bench_half(2); | |||
#if defined _WIN32 | |||
getchar(); | |||
#endif | |||
return EXIT_SUCCESS; | |||
} | |||
@@ -1,69 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<PropertyGroup Label="LolMacros"> | |||
<LolDir Condition="Exists('$(SolutionDir)\lol')">$(SolutionDir)\lol</LolDir> | |||
<LolDir Condition="!Exists('$(SolutionDir)\lol')">$(SolutionDir)</LolDir> | |||
</PropertyGroup> | |||
<ItemGroup Label="ProjectConfigurations"> | |||
<ProjectConfiguration Include="Debug|NX64"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>NX64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|ORBIS"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>ORBIS</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|Win32"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>Win32</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|x64"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>x64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|NX64"> | |||
<Configuration>Release</Configuration> | |||
<Platform>NX64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|ORBIS"> | |||
<Configuration>Release</Configuration> | |||
<Platform>ORBIS</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|Win32"> | |||
<Configuration>Release</Configuration> | |||
<Platform>Win32</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|x64"> | |||
<Configuration>Release</Configuration> | |||
<Platform>x64</Platform> | |||
</ProjectConfiguration> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<ClCompile Include="benchmark\half.cpp" /> | |||
<ClCompile Include="benchmark\real.cpp" /> | |||
<ClCompile Include="benchmark\vector.cpp" /> | |||
<ClCompile Include="benchsuite.cpp" /> | |||
</ItemGroup> | |||
<Import Project="$(LolDir)\build\msbuild\lol-core.props" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol-bullet.props" /> | |||
<PropertyGroup Label="Globals"> | |||
<ProjectGuid>{B1E10086-A1DA-401A-834D-969C9DBB5CC1}</ProjectGuid> | |||
<ConfigurationType>Application</ConfigurationType> | |||
<Keyword>Win32Proj</Keyword> | |||
</PropertyGroup> | |||
<Import Project="$(LolDir)\build\msbuild\lol.config.props" /> | |||
<ImportGroup Label="ExtensionSettings"> | |||
<Import Project="$(LolDir)\build\msbuild\lolfx.props" /> | |||
</ImportGroup> | |||
<ImportGroup Label="PropertySheets"> | |||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol.vars.props" /> | |||
</ImportGroup> | |||
<PropertyGroup Label="UserMacros" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol.rules.props" /> | |||
<ItemDefinitionGroup /> | |||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> | |||
<ImportGroup Label="ExtensionTargets"> | |||
<Import Project="$(LolDir)\build\msbuild\lolfx.targets" /> | |||
</ImportGroup> | |||
</Project> |
@@ -1,39 +0,0 @@ | |||
// | |||
// bluenoise — create a N×N blue noise kernel | |||
// | |||
// Copyright © 2016—2017 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// This program is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <lol/engine.h> | |||
using namespace lol; | |||
int main(int argc, char **argv) | |||
{ | |||
UNUSED(argc, argv); | |||
ivec2 const size(64); | |||
auto const &kernel = image::kernel::blue_noise(size, ivec2(8)); | |||
image im(size.xy); | |||
array2d<vec4> &data = im.lock2d<PixelFormat::RGBA_F32>(); | |||
for (int j = 0; j < size.y; ++j) | |||
for (int i = 0; i < size.x; ++i) | |||
data[i][j] = vec4(vec3(kernel[i][j]), 1.0f); | |||
im.unlock2d(data); | |||
im.save("bluenoise.png"); | |||
return 0; | |||
} | |||
@@ -1,754 +0,0 @@ | |||
// | |||
// Lol Engine — BtPhys tutorial | |||
// | |||
// Copyright © 2012—2019 Sam Hocevar <sam@hocevar.net> | |||
// © 2009—2015 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <lol/engine.h> | |||
#include "loldebug.h" | |||
using namespace lol; | |||
#include "physics/lolphysics.h" | |||
#include "physics/easyphysics.h" | |||
#define CAT_MODE 0 | |||
#define OBJ_SIZE 2.f | |||
#define NB_SPRITE 4 | |||
#define PARTICLE_SIZE 4 | |||
#include "physicobject.h" | |||
#include "btphystest.h" | |||
using namespace lol::phys; | |||
#define CUBE_HALF_EXTENTS .5f | |||
#define EXTRA_HEIGHT 1.f | |||
#define BASE_TIME 2.f | |||
#define ZERO_TIME (BASE_TIME + rand(-BASE_TIME * .4f, BASE_TIME * .4f)) | |||
#define ZERO_SPEED 3.5f | |||
#define JUMP_HEIGHT 30.f | |||
#define JUMP_STRAFE .5f | |||
#define TARGET_TIMER 10.f + (rand(4.f) - 2.f) | |||
int gNumObjects = 16; | |||
#if CAT_MODE | |||
#define USE_WALL 1 | |||
#define USE_BODIES 1 | |||
#else | |||
#define USE_WALL 1 | |||
#define USE_PLATFORM 0 | |||
#define USE_ROPE 0 | |||
#define USE_BODIES 1 | |||
#define USE_ROTATION 1 | |||
#define USE_CHARACTER 0 | |||
#define USE_STAIRS 0 | |||
#endif | |||
LOLFX_RESOURCE_DECLARE(front_camera_sprite); | |||
BtPhysTest::BtPhysTest(bool editor) | |||
{ | |||
m_init_status = 0; | |||
} | |||
void BtPhysTest::InitApp() | |||
{ | |||
m_init_status = 1; | |||
m_loop_value = .0f; | |||
#if CAT_MODE | |||
/* cat datas setup */ | |||
m_cat_texture = Tiler::Register("data/CatsSheet.png", ivec2::zero, ivec2(0,1)); | |||
m_fov_dp = .0f; | |||
m_loc_dp = .0f; | |||
#endif //CAT_MODE | |||
/* Create a camera that matches the settings of XNA BtPhysTest */ | |||
m_camera = new Camera(); | |||
#if CAT_MODE | |||
m_camera->SetView(vec3(70.f, 50.f, 0.f), | |||
vec3(0.f, 0.f, 0.f), | |||
vec3(0, 1, 0)); | |||
m_camera->SetProjection(radians(60.f), .1f, 1000.f, (float)Video::GetSize().x, (float)Video::GetSize().y / (float)Video::GetSize().x); | |||
m_target_timer = TARGET_TIMER; | |||
m_cam_target = -1; | |||
#else | |||
m_camera->SetView(vec3(50.f, 50.f, 0.f), | |||
vec3(0.f, 0.f, 0.f), | |||
vec3(0, 1, 0)); | |||
m_camera->SetProjection(radians(45.f), .1f, 1000.f, (float)Video::GetSize().x, (float)Video::GetSize().y / (float)Video::GetSize().x); | |||
#endif | |||
Scene& scene = Scene::GetScene(); | |||
scene.PushCamera(m_camera); | |||
m_ready = false; | |||
m_simulation = new Simulation(); | |||
m_simulation->SetWorldLimit(vec3(-1000.0f, -1000.0f, -1000.0f), vec3(1000.0f, 1000.0f, 1000.0f)); | |||
m_simulation->Init(); | |||
vec3 NewGravity = vec3(.0f, -10.0f, .0f); | |||
m_simulation->SetGravity(NewGravity); | |||
m_simulation->SetContinuousDetection(true); | |||
m_simulation->SetTimestep(1.f / 120.f); | |||
Ticker::Ref(m_simulation); | |||
/* Add a white directional light */ | |||
m_light1 = new Light(); | |||
m_light1->SetPosition(vec3(0.2f, 0.2f, 0.f)); | |||
m_light1->SetColor(vec4(0.5f, 0.5f, 0.5f, 1.f)); | |||
m_light1->SetType(LightType::Directional); | |||
Ticker::Ref(m_light1); | |||
/* Add an orangeish point light */ | |||
m_light2 = new Light(); | |||
m_light2->SetPosition(vec3(-15.f, 15.f, 15.f)); | |||
m_light2->SetColor(vec4(0.4f, 0.3f, 0.2f, 1.f)); | |||
m_light2->SetType(LightType::Point); | |||
Ticker::Ref(m_light2); | |||
float offset = 29.5f; | |||
vec3 pos_offset = vec3(.0f, 30.f, .0f); | |||
#if USE_STAIRS | |||
{ | |||
vec3 new_offset = vec3(1.0f, .125f, .0f); | |||
quat NewRotation = quat::fromeuler_xyz(0.f, 0.f, 0.f); | |||
vec3 NewPosition = pos_offset + vec3(5.0f, -29.f, 15.0f); | |||
{ | |||
NewRotation = quat::fromeuler_xyz(0.f, 0.f, radians(30.f)); | |||
NewPosition += vec3(4.0f, .0f, -4.0f); | |||
PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 3); | |||
Ticker::Ref(NewPhyobj); | |||
m_stairs_list << NewPhyobj; | |||
} | |||
{ | |||
NewRotation = quat::fromeuler_xyz(0.f, 0.f, radians(40.f)); | |||
NewPosition += vec3(4.0f, .0f, -4.0f); | |||
PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 3); | |||
Ticker::Ref(NewPhyobj); | |||
m_stairs_list << NewPhyobj; | |||
} | |||
NewPosition = pos_offset + vec3(5.0f, -29.5f, 15.0f); | |||
NewRotation = quat::fromeuler_xyz(0.f, 0.f, 0.f); | |||
for (int i=0; i < 15; i++) | |||
{ | |||
NewPosition += new_offset; | |||
PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 3); | |||
Ticker::Ref(NewPhyobj); | |||
m_stairs_list << NewPhyobj; | |||
} | |||
} | |||
#endif //USE_STAIRS | |||
#if USE_WALL | |||
{ | |||
for (int i=0; i < 6; i++) | |||
{ | |||
vec3 NewPosition = vec3(.0f); | |||
quat NewRotation = quat(1.f); | |||
PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation); | |||
int idx = i/2; | |||
NewPosition = pos_offset; | |||
NewPosition[idx] += offset; | |||
offset *= -1.f; | |||
if (idx != 1) | |||
{ | |||
vec3 NewAxis = vec3(.0f); | |||
NewAxis[2 - idx] = 1; | |||
NewRotation = quat::rotate(radians(90.f), NewAxis); | |||
} | |||
NewPhyobj->SetTransform(NewPosition, NewRotation); | |||
Ticker::Ref(NewPhyobj); | |||
m_ground_list << NewPhyobj; | |||
} | |||
} | |||
#endif //USE_WALL | |||
PhysicsObject* BasePhyobj = nullptr; | |||
#if USE_PLATFORM | |||
{ | |||
quat NewRotation = quat::fromeuler_xyz(0.f, 0.f, 0.f); | |||
vec3 NewPosition = pos_offset + vec3(5.0f, -25.0f, -15.0f); | |||
PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1); | |||
m_platform_list << NewPhyobj; | |||
Ticker::Ref(NewPhyobj); | |||
NewPosition = pos_offset + vec3(-15.0f, -25.0f, 5.0f); | |||
NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1); | |||
BasePhyobj = NewPhyobj; | |||
m_platform_list << NewPhyobj; | |||
Ticker::Ref(NewPhyobj); | |||
NewRotation = quat::fromeuler_xyz(0.f, 0.f, radians(90.f)); | |||
NewPosition = pos_offset + vec3(-20.0f, -25.0f, 5.0f); | |||
NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1); | |||
NewPhyobj->GetPhysic()->AttachTo(BasePhyobj->GetPhysic(), true, true); | |||
m_platform_list << NewPhyobj; | |||
Ticker::Ref(NewPhyobj); | |||
//NewPosition += vec3(-0.0f, .0f, .0f); | |||
//NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1); | |||
//NewPhyobj->GetPhysic()->AttachTo(BasePhyobj->GetPhysic(), true, false); | |||
//m_platform_list << NewPhyobj; | |||
//Ticker::Ref(NewPhyobj); | |||
//NewPosition += vec3(-2.0f, .0f, .0f); | |||
//NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1); | |||
//NewPhyobj->GetPhysic()->AttachTo(BasePhyobj->GetPhysic(), false, false); | |||
//m_platform_list << NewPhyobj; | |||
//Ticker::Ref(NewPhyobj); | |||
} | |||
#endif //USE_PLATFORM | |||
#if USE_CHARACTER | |||
{ | |||
quat NewRotation = quat::fromeuler_xyz(0.f, 0.f, 0.f); | |||
vec3 NewPosition = pos_offset + vec3(-5.0f, -10.0f, 15.0f); | |||
PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 2); | |||
m_character_list << NewPhyobj; | |||
Ticker::Ref(NewPhyobj); | |||
//NewPhyobj->GetCharacter()->AttachTo(BasePhyobj->GetPhysic(), true, true); | |||
} | |||
#endif //USE_CHARACTER | |||
#if USE_BODIES | |||
{ | |||
for (int x=0; x < 6; x++) | |||
{ | |||
for (int y=0; y < 2; y++) | |||
{ | |||
for (int z=0; z < 5; z++) | |||
{ | |||
PhysicsObject* new_physobj = new PhysicsObject(m_simulation, 1000.f, | |||
vec3(-20.f, 15.f, -20.f) + | |||
#if CAT_MODE | |||
vec3(rand(4.f), rand(2.f), rand(4.f)) - | |||
vec3(2.f , 1.f , 2.f) + | |||
#endif //CAT_MODE | |||
vec3(8.f * (float)x, 8.f * (float)y, 8.f * (float)z)); | |||
m_physobj_list.push(new_physobj, ZERO_TIME); | |||
Ticker::Ref(new_physobj); | |||
} | |||
} | |||
} | |||
} | |||
#endif //USE_BODIES | |||
#if USE_ROPE | |||
{ | |||
array<PhysicsObject*> RopeElements; | |||
for (int i = 0; i < 14; i++) | |||
{ | |||
PhysicsObject* new_physobj = new PhysicsObject(m_simulation, 1000.f, | |||
vec3(0.f, 15.f, -20.f) + | |||
vec3(0.f, 0.f, 2.f * (float)i), 1); | |||
RopeElements << new_physobj; | |||
m_physobj_list.push(new_physobj, ZERO_TIME); | |||
Ticker::Ref(new_physobj); | |||
if (RopeElements.count() > 1) | |||
{ | |||
EasyConstraint* new_constraint = new EasyConstraint(); | |||
vec3 A2B = .5f * (RopeElements[i]->GetPhysic()->GetTransform()[3].xyz - | |||
RopeElements[i - 1]->GetPhysic()->GetTransform()[3].xyz); | |||
new_constraint->SetPhysObjA(RopeElements[i - 1]->GetPhysic(), lol::mat4::translate(A2B)); | |||
new_constraint->SetPhysObjB(RopeElements[i]->GetPhysic(), lol::mat4::translate(-A2B)); | |||
new_constraint->InitConstraintToPoint2Point(); | |||
new_constraint->DisableCollisionBetweenObjs(true); | |||
new_constraint->AddToSimulation(m_simulation); | |||
m_constraint_list << new_constraint; | |||
} | |||
} | |||
} | |||
#endif //USE_ROPE | |||
} | |||
BtPhysTest::~BtPhysTest() | |||
{ | |||
Scene& scene = Scene::GetScene(); | |||
scene.PopCamera(m_camera); | |||
Ticker::Unref(m_light1); | |||
Ticker::Unref(m_light2); | |||
#if CAT_MODE | |||
/* cat datas setup */ | |||
Shader::Destroy(m_cat_shader); | |||
Tiler::Deregister(m_cat_texture); | |||
#endif //CAT_MODE | |||
while (m_constraint_list.count()) | |||
{ | |||
EasyConstraint* CurPop = m_constraint_list.last(); | |||
m_constraint_list.pop(); | |||
CurPop->RemoveFromSimulation(m_simulation); | |||
delete CurPop; | |||
} | |||
array<PhysicsObject*> objects | |||
= m_ground_list | |||
+ m_stairs_list | |||
+ m_character_list | |||
+ m_platform_list; | |||
while (m_physobj_list.count()) | |||
{ | |||
objects << m_physobj_list.last().m1; | |||
m_physobj_list.pop(); | |||
} | |||
m_ground_list.clear(); | |||
m_stairs_list.clear(); | |||
m_character_list.clear(); | |||
m_platform_list.clear(); | |||
while (objects.count()) | |||
{ | |||
PhysicsObject* CurPop = objects.pop(); | |||
CurPop->GetPhysic()->RemoveFromSimulation(m_simulation); | |||
Ticker::Unref(CurPop); | |||
} | |||
//while (m_ground_list.count()) | |||
//{ | |||
// PhysicsObject* CurPop = m_ground_list.last(); | |||
// m_ground_list.pop(); | |||
// CurPop->GetPhysic()->RemoveFromSimulation(m_simulation); | |||
// Ticker::Unref(CurPop); | |||
//} | |||
//while (m_stairs_list.count()) | |||
//{ | |||
// PhysicsObject* CurPop = m_stairs_list.last(); | |||
// m_stairs_list.pop(); | |||
// CurPop->GetPhysic()->RemoveFromSimulation(m_simulation); | |||
// Ticker::Unref(CurPop); | |||
//} | |||
//while (m_character_list.count()) | |||
//{ | |||
// PhysicsObject* CurPop = m_character_list.last(); | |||
// m_character_list.pop(); | |||
// CurPop->GetCharacter()->RemoveFromSimulation(m_simulation); | |||
// Ticker::Unref(CurPop); | |||
//} | |||
//while (m_platform_list.count()) | |||
//{ | |||
// PhysicsObject* CurPop = m_platform_list.last(); | |||
// m_platform_list.pop(); | |||
// CurPop->GetPhysic()->RemoveFromSimulation(m_simulation); | |||
// Ticker::Unref(CurPop); | |||
//} | |||
//while (m_physobj_list.count()) | |||
//{ | |||
// PhysicsObject* CurPop = m_physobj_list.last().m1; | |||
// m_physobj_list.pop(); | |||
// CurPop->GetPhysic()->RemoveFromSimulation(m_simulation); | |||
// Ticker::Unref(CurPop); | |||
//} | |||
Ticker::Unref(m_simulation); | |||
} | |||
void BtPhysTest::tick_game(float seconds) | |||
{ | |||
WorldEntity::tick_game(seconds); | |||
if (!m_init_status) | |||
{ | |||
if (Scene::GetCount()) | |||
InitApp(); | |||
return; | |||
} | |||
else if (m_init_status == 1) | |||
{ | |||
m_init_status++; | |||
return; | |||
} | |||
auto context = Debug::DrawContext::New(Color::white, 1.f); | |||
Debug::DrawGrid(vec3::zero, vec3::axis_x, vec3::axis_y, vec3::axis_z, 10.f); | |||
if (input::keyboard()->key_released(input::key::SC_Escape)) | |||
Ticker::Shutdown(); | |||
m_loop_value += seconds; | |||
if (m_loop_value > F_PI * 2.0f) | |||
m_loop_value -= F_PI * 2.0f; | |||
vec3 GroundBarycenter = vec3(.0f); | |||
vec3 PhysObjBarycenter = vec3(.0f); | |||
float factor = .0f; | |||
#if CAT_MODE | |||
#if USE_BODIES | |||
vec3 cam_center(0.f); | |||
float cam_factor = .0f; | |||
vec2 screen_min_max[2] = { vec2(FLT_MAX), vec2(-FLT_MAX) }; | |||
Scene& scene = Scene::GetScene(); | |||
mat4 world_cam = scene.GetCamera()->GetView(); | |||
mat4 cam_screen = scene.GetCamera()->GetProjection(); | |||
m_target_timer -= seconds; | |||
if (m_target_timer < .0f) | |||
{ | |||
m_target_timer = TARGET_TIMER; | |||
if (m_cam_target == -1) | |||
m_cam_target = rand(m_physobj_list.count()); | |||
else | |||
m_cam_target = -1; | |||
} | |||
for (int i = 0; i < m_physobj_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_physobj_list[i].m1; | |||
float &obj_timer = m_physobj_list[i].m2; | |||
vec3 obj_loc = PhysObj->GetPhysic()->GetTransform()[3].xyz; | |||
if (m_cam_target == -1 || m_cam_target == i) | |||
{ | |||
cam_center += obj_loc; | |||
cam_factor += 1.f; | |||
mat4 LocalPos = mat4::translate(obj_loc); | |||
vec3 vpos; | |||
LocalPos = world_cam * LocalPos; | |||
mat4 LocalPos0 = LocalPos; | |||
int j = 2; | |||
while (j-- > 0) | |||
{ | |||
if (j == 1) | |||
LocalPos = mat4::translate(vec3(-4.f)) * LocalPos0; | |||
else | |||
LocalPos = mat4::translate(vec3(4.f)) * LocalPos0; | |||
LocalPos = cam_screen * LocalPos; | |||
vpos = (LocalPos[3] / LocalPos[3].w).xyz; | |||
screen_min_max[0] = min(vpos.xy, screen_min_max[0]); | |||
screen_min_max[1] = max(vpos.xy, screen_min_max[1]); | |||
} | |||
} | |||
//Jump handling | |||
//if (length(PhysObj->GetPhysic()->GetLinearVelocity()) < ZERO_SPEED) | |||
if (lol::abs(PhysObj->GetPhysic()->GetLinearVelocity().y) < ZERO_SPEED) | |||
obj_timer -= seconds; | |||
if (obj_timer < .0f) | |||
{ | |||
PhysObj->GetPhysic()->AddImpulse(JUMP_HEIGHT * | |||
vec3(JUMP_STRAFE, 1.f, JUMP_STRAFE) * | |||
vec3(rand(-1.f, 1.f), 1.0f, rand(-1.f, 1.f)) * | |||
PhysObj->GetPhysic()->GetMass()); | |||
obj_timer = ZERO_TIME; | |||
} | |||
} | |||
float fov_ratio = max(max(lol::abs(screen_min_max[0].x), lol::abs(screen_min_max[0].y)), | |||
max(lol::abs(screen_min_max[1].x), lol::abs(screen_min_max[1].y))); | |||
vec3 new_target = cam_center / cam_factor; | |||
float fov_dp = .0f; | |||
float loc_dp = .0f; | |||
//ideally fov is on the target | |||
if (lol::abs(fov_ratio - 1.f) < .2f) | |||
fov_dp = ((m_cam_target == -1)?(.7f):(.2f)); | |||
else | |||
fov_dp = ((m_cam_target == -1)?(1.7f):(.9f)); | |||
//ideally loc is on the target | |||
if (length(new_target - m_camera->GetTarget()) < 6.f) | |||
loc_dp = ((m_cam_target == -1)?(.5f):(.03f)); | |||
else | |||
loc_dp = ((m_cam_target == -1)?(.9f):(.5f)); | |||
m_fov_dp = damp(m_fov_dp, fov_dp, 0.08f, seconds); | |||
m_loc_dp = damp(m_loc_dp, loc_dp, 0.08f, seconds); | |||
m_camera->SetFov(damp(m_camera->GetFov(), m_camera->GetFov() * fov_ratio * 1.1f, m_fov_dp, seconds)); | |||
vec3 tmp = damp(m_camera->GetTarget(), new_target, m_loc_dp, seconds); | |||
m_camera->SetView((mat4::rotate(radians(10.f) * seconds, vec3(.0f, 1.f, .0f)) * vec4(m_camera->GetPosition(), 1.0f)).xyz, | |||
tmp, vec3(0, 1, 0)); | |||
#endif //USE_BODIES | |||
#endif //CAT_MODE | |||
#if USE_WALL | |||
{ | |||
for (int i = 0; i < m_ground_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_ground_list[i]; | |||
mat4 GroundMat = PhysObj->GetTransform(); | |||
GroundBarycenter += GroundMat[3].xyz; | |||
factor += 1.f; | |||
} | |||
GroundBarycenter /= factor; | |||
for (int i = 0; i < m_ground_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_ground_list[i]; | |||
mat4 GroundMat = PhysObj->GetTransform(); | |||
vec3 CenterToGround = GroundMat[3].xyz - GroundBarycenter; | |||
vec3 CenterToCam = m_camera->GetPosition() - GroundBarycenter; | |||
if (dot(normalize(CenterToCam - CenterToGround), | |||
normalize(CenterToGround)) > 0.f) | |||
PhysObj->SetRender(false); | |||
else | |||
PhysObj->SetRender(true); | |||
} | |||
} | |||
#endif //USE_WALL | |||
#if USE_ROTATION | |||
{ | |||
for (int i = 0; i < m_ground_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_ground_list[i]; | |||
mat4 GroundMat = PhysObj->GetTransform(); | |||
mat4 CenterMx = mat4::translate(GroundBarycenter); | |||
GroundMat = inverse(CenterMx) * GroundMat; | |||
GroundMat = CenterMx * | |||
mat4(quat::fromeuler_xyz(vec3(.0f, radians(20.f), radians(20.0f)) * seconds)) | |||
* GroundMat; | |||
PhysObj->SetTransform(GroundMat[3].xyz, quat(mat3(GroundMat))); | |||
} | |||
} | |||
#endif //USE_ROTATION | |||
#if USE_PLATFORM | |||
{ | |||
for (int i = 0; i < m_platform_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_platform_list[i]; | |||
mat4 GroundMat = PhysObj->GetTransform(); | |||
if (i == 0) | |||
{ | |||
GroundMat = GroundMat * mat4(quat::fromeuler_xyz(vec3(radians(20.f), .0f, .0f) * seconds)); | |||
PhysObj->SetTransform(GroundMat[3].xyz, quat(mat3(GroundMat))); | |||
} | |||
else if (i == 1) | |||
{ | |||
GroundMat = | |||
mat4::translate(vec3(-15.0f, 5.0f, lol::cos(m_loop_value) * 8.f)) * | |||
mat4(quat::fromeuler_xyz(vec3(.0f, lol::cos(m_loop_value) * radians(20.f), .0f))); | |||
PhysObj->SetTransform(GroundMat[3].xyz, quat(mat3(GroundMat))); | |||
} | |||
} | |||
} | |||
#endif //USE_PLATFORM | |||
#if USE_CHARACTER | |||
{ | |||
auto keyboard = input::keyboard(); | |||
for (int i = 0; i < m_character_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_character_list[i]; | |||
EasyCharacterController* Character = (EasyCharacterController*)PhysObj->GetCharacter(); | |||
mat4 CtlrMx = Character->GetTransform(); | |||
vec3 movement(0.f); | |||
movement.z = (keyboard->key(input::key::SC_Right) ? 1.f : 0.f) | |||
- (keyboard->key(input::key::SC_Left) ? 1.f : 0.f); | |||
movement.x = (keyboard->key(input::key::SC_Up) ? 1.f : 0.f) | |||
- (keyboard->key(input::key::SC_Down) ? 1.f : 0.f); | |||
movement.y = (keyboard->key(input::key::SC_PageUp) ? 1.f : 0.f) | |||
- (keyboard->key(input::key::SC_PageDown) ? 1.f : 0.f); | |||
vec3 CharMove = movement * seconds * vec3(4.f, 10.f, 4.f); | |||
if (input::keyboard()->key_released(input::key::SC_Space)) | |||
Character->Jump(); | |||
Character->SetMovementForFrame(CharMove); | |||
RayCastResult HitResult; | |||
if (m_simulation->RayHits(HitResult, ERT_Closest, Character->GetTransform()[3].xyz, (Character->GetTransform()[3].xyz + vec3(.0f, -1.f, .0f)), Character)) | |||
Character->AttachTo(HitResult.m_collider_list[0], true, true); | |||
else | |||
Character->AttachTo(nullptr); | |||
} | |||
} | |||
#endif //USE_CHARACTER | |||
#if USE_CHARACTER | |||
{ | |||
PhysObjBarycenter = vec3(.0f); | |||
factor = .0f; | |||
for (int i = 0; i < m_character_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_character_list[i]; | |||
mat4 GroundMat = PhysObj->GetTransform(); | |||
PhysObjBarycenter += GroundMat[3].xyz; | |||
factor += 1.f; | |||
} | |||
PhysObjBarycenter /= factor; | |||
#if 0 | |||
m_camera->SetTarget(m_camera->GetTarget() + (seconds / (seconds + 0.18f)) * (PhysObjBarycenter - m_camera->GetTarget())); | |||
vec3 CamPosCenter = m_camera->GetTarget() + vec3(.0f, 5.0f, .0f); | |||
m_camera->SetPosition(CamPosCenter + normalize(m_camera->GetPosition() - CamPosCenter) * 20.0f); | |||
#endif | |||
} | |||
#else | |||
{ | |||
PhysObjBarycenter = vec3(.0f); | |||
for (int i = 0; i < m_physobj_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_physobj_list[i].m1; | |||
mat4 GroundMat = PhysObj->GetTransform(); | |||
PhysObjBarycenter += GroundMat[3].xyz; | |||
factor += 1.f; | |||
} | |||
PhysObjBarycenter /= factor; | |||
#if 0 | |||
m_camera->SetTarget(PhysObjBarycenter); | |||
m_camera->SetPosition(GroundBarycenter + normalize(GroundBarycenter - PhysObjBarycenter) * 60.0f); | |||
#endif | |||
} | |||
#endif //USE_CHARACTER | |||
} | |||
void BtPhysTest::tick_draw(float seconds, Scene &scene) | |||
{ | |||
WorldEntity::tick_draw(seconds, scene); | |||
if (m_init_status != 2) | |||
return; | |||
if (!m_ready) | |||
{ | |||
#if CAT_MODE | |||
/* cat datas setup */ | |||
m_cat_shader = Shader::Create(LOLFX_RESOURCE_NAME(front_camera_sprite)); | |||
#if USE_BODIES | |||
for (int i = 0; i < m_physobj_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_physobj_list[i].m1; | |||
m_cat_sdata = new CatShaderData(((1 << VertexUsage::Position) | | |||
(1 << VertexUsage::Color) | | |||
(1 << VertexUsage::TexCoord) | | |||
(1 << VertexUsage::TexCoordExt)), | |||
m_cat_shader); | |||
m_cat_sdata->m_tex_uniform = m_cat_texture->GetTexture()->GetTextureUniform(); | |||
m_cat_sdata->m_sprite_flip = ((rand(2) == 1)?(1.f):(0.f)) / (float)(NB_SPRITE * PARTICLE_SIZE); | |||
PhysObj->SetCustomShaderData(m_cat_sdata); | |||
m_cat_sdata = nullptr; | |||
} | |||
#endif //USE_BODIES | |||
#endif //CAT_MODE | |||
/* FIXME: this object never cleans up */ | |||
m_ready = true; | |||
} | |||
else | |||
{ | |||
#if CAT_MODE | |||
for (int i = 0; i < m_physobj_list.count(); i++) | |||
{ | |||
PhysicsObject* PhysObj = m_physobj_list[i].m1; | |||
CatShaderData* ShaderData = (CatShaderData*)PhysObj->GetCustomShaderData(); | |||
ShaderData->m_sprite_orientation = damp(ShaderData->m_sprite_orientation, | |||
F_PI_4 * ((ShaderData->m_sprite_flip * 2.f * (float)(NB_SPRITE * PARTICLE_SIZE)) - 1.f) * | |||
clamp(PhysObj->GetPhysic()->GetLinearVelocity().y / 20.0f, -1.f, 1.f), | |||
0.1f, seconds); | |||
} | |||
#endif //CAT_MODE | |||
} | |||
//Video::set_clear_color(vec4(0.0f, 0.0f, 0.12f, 1.0f)); | |||
} | |||
//----------------------------------------------------------------------------- | |||
// CShaderData | |||
//----------------------------------------------------------------------------- | |||
CatShaderData::CatShaderData(uint32_t vert_decl_flags, std::shared_ptr<Shader> shader) | |||
: GpuShaderData(vert_decl_flags, shader, DebugRenderMode::Default) | |||
{ | |||
m_sprite_orientation = .0f; | |||
m_sprite_flip = .0f; | |||
SetupDefaultData(); | |||
} | |||
//----------------------------------------------------------------------------- | |||
void CatShaderData::SetupDefaultData() | |||
{ | |||
AddUniform("u_model_view"); | |||
AddUniform("u_normal_mat"); | |||
AddUniform("u_proj"); | |||
AddUniform("u_texture"); | |||
AddUniform("u_sprite_orientation"); | |||
AddUniform("u_sprite_flip"); | |||
} | |||
//----------------------------------------------------------------------------- | |||
void CatShaderData::SetupShaderDatas(mat4 const &model) | |||
{ | |||
Scene& scene = Scene::GetScene(); | |||
mat4 proj = scene.GetCamera()->GetProjection(); | |||
mat4 view = scene.GetCamera()->GetView(); | |||
mat4 modelview = view * model; | |||
mat3 normalmat = transpose(inverse(mat3(view))); | |||
m_shader->SetUniform(*GetUniform("u_model_view"), modelview); | |||
m_shader->SetUniform(*GetUniform("u_normal_mat"), normalmat); | |||
m_shader->SetUniform(*GetUniform("u_proj"), proj); | |||
m_shader->SetUniform(*GetUniform("u_texture"), m_tex_uniform, 0); | |||
m_shader->SetUniform(*GetUniform("u_sprite_orientation"), m_sprite_orientation); | |||
m_shader->SetUniform(*GetUniform("u_sprite_flip"), m_sprite_flip); | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
sys::init(argc, argv); | |||
Application app("BtPhysTest", ivec2(1280, 960), 60.0f); | |||
new BtPhysTest(argc > 1); | |||
app.ShowPointer(false); | |||
app.Run(); | |||
return EXIT_SUCCESS; | |||
} | |||
@@ -1,115 +0,0 @@ | |||
// | |||
// Lol Engine — Bullet physics test | |||
// | |||
// Copyright © 2012—2019 Sam Hocevar <sam@hocevar.net> | |||
// © 2009—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#pragma once | |||
#include <memory> | |||
#include <string> | |||
#include <map> | |||
class CatShaderData : public GpuShaderData | |||
{ | |||
friend class CRenderer; | |||
public: | |||
//--- | |||
CatShaderData(uint32_t vert_decl_flags, std::shared_ptr<Shader> shader); | |||
//--- | |||
void SetupDefaultData(); | |||
virtual void SetupShaderDatas(mat4 const &model); | |||
//-- | |||
virtual std::string GetInVertexName() { return "in_vertex"; } | |||
virtual std::string GetInNormalName() { return "in_normal"; } | |||
virtual std::string GetInColorName() { return "in_color"; } | |||
virtual std::string GetInTexCoordName() { return "in_texcoord"; } | |||
TextureUniform m_tex_uniform; | |||
float m_sprite_orientation; | |||
float m_sprite_flip; | |||
}; | |||
class BtPhysTest : public WorldEntity | |||
{ | |||
public: | |||
BtPhysTest(bool editor = false); | |||
virtual ~BtPhysTest(); | |||
std::string GetName() const { return "<BtPhysTest>"; } | |||
protected: | |||
virtual void tick_game(float seconds); | |||
virtual void tick_draw(float seconds, Scene &scene); | |||
void InitApp(); | |||
private: | |||
//MeshViewerInput --------------------------------------------------------- | |||
struct BtPhysTestKeyInputBase : public StructSafeEnum | |||
{ | |||
enum Type | |||
{ | |||
KEY_START = 0, | |||
KEY_MOVE_FORWARD = KEY_START, | |||
KEY_MOVE_BACK, | |||
KEY_MOVE_LEFT, | |||
KEY_MOVE_RIGHT, | |||
KEY_MOVE_UP, | |||
KEY_MOVE_DOWN, | |||
KEY_MOVE_JUMP, | |||
KEY_QUIT, | |||
KEY_MAX | |||
}; | |||
protected: | |||
virtual bool BuildEnumMap(std::map<int64_t, std::string>& enum_map) | |||
{ | |||
enum_map[KEY_MOVE_FORWARD] = input::key_to_name(input::key::SC_Up); | |||
enum_map[KEY_MOVE_BACK] = input::key_to_name(input::key::SC_Down); | |||
enum_map[KEY_MOVE_LEFT] = input::key_to_name(input::key::SC_Left); | |||
enum_map[KEY_MOVE_RIGHT] = input::key_to_name(input::key::SC_Right); | |||
enum_map[KEY_MOVE_UP] = input::key_to_name(input::key::SC_PageUp); | |||
enum_map[KEY_MOVE_DOWN] = input::key_to_name(input::key::SC_PageDown); | |||
enum_map[KEY_MOVE_JUMP] = input::key_to_name(input::key::SC_Space); | |||
enum_map[KEY_QUIT] = input::key_to_name(input::key::SC_Escape); | |||
return true; | |||
} | |||
}; | |||
typedef SafeEnum<BtPhysTestKeyInputBase> BtPhysTestKeyInput; | |||
TileSet* m_cat_texture; | |||
std::shared_ptr<Shader> m_cat_shader; | |||
CatShaderData* m_cat_sdata; | |||
Camera* m_camera; | |||
Light* m_light1; | |||
Light* m_light2; | |||
int m_init_status; | |||
bool m_ready; | |||
lol::phys::Simulation* m_simulation; | |||
array<EasyConstraint*> m_constraint_list; | |||
array<PhysicsObject*, float> m_physobj_list; | |||
array<PhysicsObject*> m_ground_list; | |||
array<PhysicsObject*> m_platform_list; | |||
array<PhysicsObject*> m_character_list; | |||
array<PhysicsObject*> m_stairs_list; | |||
float m_loop_value; | |||
float m_target_timer; | |||
int m_cam_target; | |||
float m_fov_dp; | |||
float m_loc_dp; | |||
}; | |||
@@ -1,88 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<PropertyGroup Label="LolMacros"> | |||
<LolDir Condition="Exists('$(SolutionDir)\lol')">$(SolutionDir)\lol</LolDir> | |||
<LolDir Condition="!Exists('$(SolutionDir)\lol')">$(SolutionDir)</LolDir> | |||
</PropertyGroup> | |||
<ItemGroup Label="ProjectConfigurations"> | |||
<ProjectConfiguration Include="Debug|NX64"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>NX64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|ORBIS"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>ORBIS</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|Win32"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>Win32</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|x64"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>x64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|NX64"> | |||
<Configuration>Release</Configuration> | |||
<Platform>NX64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|ORBIS"> | |||
<Configuration>Release</Configuration> | |||
<Platform>ORBIS</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|Win32"> | |||
<Configuration>Release</Configuration> | |||
<Platform>Win32</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|x64"> | |||
<Configuration>Release</Configuration> | |||
<Platform>x64</Platform> | |||
</ProjectConfiguration> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<ClInclude Include="btphystest.h" /> | |||
<ClInclude Include="physicobject.h" /> | |||
<ClInclude Include="physics\bulletcharactercontroller.h" /> | |||
<ClInclude Include="physics\easycharactercontroller.h" /> | |||
<ClInclude Include="physics\easyconstraint.h" /> | |||
<ClInclude Include="physics\easyphysics.h" /> | |||
<ClInclude Include="physics\lolbtphysicsintegration.h" /> | |||
<ClInclude Include="physics\lolphysics.h" /> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<ClCompile Include="btphystest.cpp" /> | |||
<ClCompile Include="physics\bulletcharactercontroller.cpp" /> | |||
<ClCompile Include="physics\easycharactercontroller.cpp" /> | |||
<ClCompile Include="physics\easyconstraint.cpp" /> | |||
<ClCompile Include="physics\easyphysics.cpp" /> | |||
</ItemGroup> | |||
<Import Project="$(LolDir)\build\msbuild\lol-core.props" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol-bullet.props" /> | |||
<ItemGroup> | |||
<None Include="Makefile.am"> | |||
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild> | |||
</None> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<LolFxCompile Include="front_camera_sprite.lolfx" /> | |||
</ItemGroup> | |||
<PropertyGroup Label="Globals"> | |||
<ProjectGuid>{ee203b88-44cf-4859-9d42-7a1f43fecb52}</ProjectGuid> | |||
<ConfigurationType>Application</ConfigurationType> | |||
<Keyword>Win32Proj</Keyword> | |||
</PropertyGroup> | |||
<Import Project="$(LolDir)\build\msbuild\lol.config.props" /> | |||
<ImportGroup Label="ExtensionSettings"> | |||
<Import Project="$(LolDir)\build\msbuild\lolfx.props" /> | |||
</ImportGroup> | |||
<ImportGroup Label="PropertySheets"> | |||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol.vars.props" /> | |||
</ImportGroup> | |||
<PropertyGroup Label="UserMacros" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol.rules.props" /> | |||
<ItemDefinitionGroup /> | |||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> | |||
<ImportGroup Label="ExtensionTargets"> | |||
<Import Project="$(LolDir)\build\msbuild\lolfx.targets" /> | |||
</ImportGroup> | |||
</Project> |
@@ -1,54 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<ItemGroup> | |||
<ClInclude Include="btphystest.h" /> | |||
<ClInclude Include="physicobject.h" /> | |||
<ClInclude Include="physics\easycharactercontroller.h"> | |||
<filter>physics</filter> | |||
</ClInclude> | |||
<ClInclude Include="physics\lolphysics.h"> | |||
<filter>physics</filter> | |||
</ClInclude> | |||
<ClInclude Include="physics\easyconstraint.h"> | |||
<filter>physics</filter> | |||
</ClInclude> | |||
<ClInclude Include="physics\easyphysics.h"> | |||
<filter>physics</filter> | |||
</ClInclude> | |||
<ClInclude Include="physics\lolbtphysicsintegration.h"> | |||
<filter>physics</filter> | |||
</ClInclude> | |||
<ClInclude Include="physics\bulletcharactercontroller.h"> | |||
<filter>physics</filter> | |||
</ClInclude> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<ClCompile Include="btphystest.cpp" /> | |||
<ClCompile Include="physics\easycharactercontroller.cpp"> | |||
<filter>physics</filter> | |||
</ClCompile> | |||
<ClCompile Include="physics\easyconstraint.cpp"> | |||
<filter>physics</filter> | |||
</ClCompile> | |||
<ClCompile Include="physics\easyphysics.cpp"> | |||
<filter>physics</filter> | |||
</ClCompile> | |||
<ClCompile Include="physics\bulletcharactercontroller.cpp"> | |||
<filter>physics</filter> | |||
</ClCompile> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<Filter Include="generated"> | |||
<UniqueIdentifier>{4fc7662b-b17a-49b9-acd1-0cf767183b06}</UniqueIdentifier> | |||
</Filter> | |||
<Filter Include="physics"> | |||
<UniqueIdentifier>{ccecd634-9321-4c49-9471-e9da50dda6d3}</UniqueIdentifier> | |||
</Filter> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<None Include="Makefile.am" /> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<LolFxCompile Include="front_camera_sprite.lolfx" /> | |||
</ItemGroup> | |||
</Project> |
@@ -1,110 +0,0 @@ | |||
addlight 0 position (0 0 15) color #bbb | |||
addlight 1 position (0 0 15) color #bbb | |||
//addlight 1 position (3 10 0) color #444 | |||
clearcolor #ddd | |||
showgizmo true | |||
showlight true | |||
//SCENE SETUP END | |||
//addlight 0.0 position (1 0 1) color #0ff | |||
//addlight 0.0 position (-0.2 -1 -0.5) color (.0 .2 .5 1) | |||
//custom setmesh "sc#f00 ab 2 ty 1.5 ab 2" | |||
custom setmesh " | |||
//tqw | |||
//CMD TEST | |||
//sc#0f0 asph 1 10 | |||
//sc#0f0 ab 10 | |||
//sc#0f0 afcb 1 -.2 | |||
//sc#0f0 acg 8 1 1 1 2 2 1.5 1.5 -.4 | |||
//sc#0f0 as 6 1 2 | |||
//sc#0f0 scb#f00 aes 6 1 2 2 | |||
//sc#0f0 ac 6 5 2 2 false true true | |||
//sc#0f0 aq 1 | |||
//splt 2 smth 4 0 1 | |||
//[sc#0f0 ac 3 .5 .4 0 ty .25 [ad 3 .4 sy -1] ty .5 ac 3 1 .1 ty .5 dup [ rz 90 ry 90 scv#00f dup [ ry 90 scv#f00 ] ] ] | |||
//[sc#fff ab .1] | |||
//[sc#0f0 ac 3 .5 .4 0 ty .25 [ad 3 .4 sy -1] ty .5 ac 3 1 .1 ty .5 dup[rz 90 ry 90 scv#00f dup[ry 90 scv#f00]]][sc#fff ab .1] | |||
//[sc#fff ab 1 tx .5 ty .5] | |||
//[sc#fff ab 1 tx -.5 ty -.5] | |||
//[sc#fff ac 3 .5 .4 0 ty .25 [ad 3 .4 sy -1] ty .5 ac 3 1 .1 ty .5 [ad 3 .1 sy -1] ty 1] | |||
//smth 3 1 1 smth 8 0 1 | |||
//[sc#fff loop 4 [ [loop 4 [ab 1 tx 2]] tz 2]] | |||
//[sc#f00 scb#f00 ac 3 .5 .4 0 ty .25 [ad 3 .4 sy -1] ty .5 ac 3 1 .1 .1 ty .5 rz -90] | |||
//[sc#00f scb#00f ac 3 .5 .4 0 ty .25 [ad 3 .4 sy -1] ty .5 ac 3 1 .1 .1 ty .5 rx 90] | |||
//[sc#f00 ab .2 tx 1] | |||
//[sc#0f0 ab .2 ty 1] | |||
//[sc#00f ab .2 tz 1] | |||
//sc#0f0 ab 2 ty 1.5 ab 2 | |||
//sc#00f ab 2 ty 1.5 ab 2 | |||
//sc#00f tqw lp 5[tz 11 [lp 6 [tx 5 ty 5 afcb 10 -1 ]]] tz -22 | |||
// tqw | |||
sc#f00 ab 10 | |||
//tz 5 | |||
//vm | |||
// splt 1 | |||
// rj .2 | |||
// splt 1 | |||
// rj .2 | |||
// smth 1 0 1 | |||
//[sc#66f afcb(10) .25tx0]csgs[sc#fff afcb(10).25t(2)][[sc#6f6 afcb(7).25]csgs[sc#fff afcb(7).25t(1.5)]][[sc#f44 asph4 12t(-2.5)]csga[sc#fff afcb(7).25t(1.4)]csgs[sc#fff afcb(7).25t(2.5)]][[sc#ff0 ato6 2.5 1.2rx90tz-1.25tx-.9][sc#ff0 ab.5 2.1 .5dup[rz90sx.5ty-.8tx-.28]ty.55tx.25tz-.4taz1 1sy.8sx.8ty-.55tx-.25tz.4tz-1.2tx1.2]tz1.25tx1.25dup[sx-1ry90]tz-1.25tx-1.25] | |||
" | |||
//splt 0 | |||
//test | |||
//[sc#f8f ab 1 splt 4 twy 90] | |||
// splt 5 twy 90 0 | |||
//[sc#f8f afcb 10 10 10 .25 tx 0 splt 4 twy 1.6 0 ] | |||
//sc#fff | |||
//[afcb 1 1 1 -.1 tx 1] | |||
//[afcb 1 1 1 -.1 tx 0] | |||
//[afcb 1 1 1 -.1 tx -1] | |||
//[[afcb 1 1 1 -.1 tx 1] | |||
//[afcb 1 1 1 -.1 tx 0] | |||
//[afcb 1 1 1 -.1 tx -1]tz 1] | |||
//[[afcb 1 1 1 -.1 tx 1] | |||
//[afcb 1 1 1 -.1 tx 0] | |||
//[afcb 1 1 1 -.1 tx -1]tz -1] | |||
//[afcb 3 .2 3 -.05 ty -.6] | |||
//[sc#fff scb#fff ato 20 8 12 rx0] | |||
//[sc#fff scb#fff acg 8 2 5 1 6 8 4 2 .1 1] | |||
//[sc#fff ab 4 4 4 ]//twy 45 0 bdxy 90 0 splt 5 tz 2 | |||
//[sc#88f ab 4 4 4 tx 4 ab 4 4 4 tx -2 tax .4 .4 0] | |||
//[sc#88f ab .25 1 1 tx .25 ab .25 1 1 tx .25 ab .25 1 1 tx .25 ab .25 1 1 tx .125 stx 10 0 0] | |||
// tax -2 0 0 0 | |||
//[sc#88f ab 4 4 4 tx 4 ab 4 4 4 tx -2 shz 1 0 0 0] | |||
//[sc#fff asph 4 4] | |||
//[sc#ff2 asph 4 4 tax .4 .4 0] | |||
//[sc#ff2 asph 2 4] | |||
//[sc#fff acap 1 4 4] | |||
//[sc#fff scb#fff ac 10 4 4 4 0 0 1] | |||
//[sc#ff2 scb#ff2 ad 10 4 0] | |||
//[sc#fff scb#fff at 4 1] | |||
//[sc#fff scb#000 aq 4 1] | |||
//[sc#fff scb#2ff aes 5 3 6 2] | |||
//[sc#fff scb#2ff as 4 2 4 0 0] | |||
//[sc#fff scb#fff acg 2 10 .1 .1 .4 .4 .1 .1 0 1] | |||
//[sc#ff2 asph 2 10 10 10] | |||
//[sc#400 asph 2 10 10 10 t 2 2 2 csgs] |
@@ -1,17 +0,0 @@ | |||
em0 = EasyMesh.New("Mesh0"); | |||
em0:SetColor("#f00") | |||
em0:AddBox(2) | |||
em0:TranslateY(1.5) | |||
em0:AddBox(2.5) | |||
em1 = EasyMesh.New("Mesh1"); | |||
em1:SetColor("#0f0") | |||
em1:AddBox(2.5) | |||
em1:TranslateY(2) | |||
em1:AddBox(2) | |||
@@ -1,19 +0,0 @@ | |||
s0 = SceneSetup.New("DefaultSetup") | |||
s0:AddLight("Point") | |||
s0:Position(0, 0, 15) | |||
s0:Color("#bbb") | |||
s0:AddLight("Directional") | |||
s0:Position(0, 0, 15) | |||
s0:Color("#bbb") | |||
--addlight 1 position (3 10 0) color #444 | |||
s0:Setup() | |||
s0:Color("#ddd") | |||
s0:Show("Gizmo") | |||
s0:Show("Light") | |||
--SCENE SETUP END | |||
--addlight 0.0 position (1 0 1) color #0ff | |||
--addlight 0.0 position (-0.2 -1 -0.5) color (.0 .2 .5 1) |
@@ -1,115 +0,0 @@ | |||
[vert.glsl] | |||
#version 130 | |||
in vec3 in_position; | |||
in vec4 in_color; | |||
in vec4 in_texcoord; | |||
uniform mat4 u_model_view; | |||
uniform mat3 u_normal_mat; | |||
uniform mat4 u_proj; | |||
uniform float u_sprite_orientation; | |||
out vec4 pass_texcoord; | |||
out vec4 pass_color; | |||
void main(void) | |||
{ | |||
vec4 vertex = u_model_view * vec4(in_position - vec3(0.0,0.5,0.0), 1.0); | |||
vec3 v_offset = vec3(1.0 * in_texcoord.z, -1.0 * in_texcoord.w, 0.0); | |||
float sinX = sin(u_sprite_orientation); | |||
float cosX = cos(u_sprite_orientation); | |||
float sinY = sinX; | |||
mat2 rotationMatrix = mat2(cosX, -sinX, sinY, cosX); | |||
v_offset.xy = rotationMatrix * v_offset.xy; | |||
//Billboard calculations | |||
vertex.xyz += v_offset; | |||
//pass datas | |||
pass_texcoord = in_texcoord; | |||
pass_color = in_color; | |||
gl_Position = u_proj * vertex; | |||
} | |||
[frag.glsl] | |||
#version 130 | |||
#if defined GL_ES | |||
precision highp float; | |||
#endif | |||
in vec4 pass_texcoord; | |||
in vec4 pass_color; | |||
uniform sampler2D u_texture; | |||
uniform float u_sprite_flip; | |||
const float cos_45 = 0.70710678118; | |||
const float PI = 3.14159265358979323846264; | |||
vec3 rgb2hsv(vec3 c) | |||
{ | |||
vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0); | |||
vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy); | |||
vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx); | |||
float d = q.x - min(q.w, q.y); | |||
float e = 1.0e-10; | |||
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x); | |||
} | |||
vec3 hsv2rgb(vec3 c) | |||
{ | |||
vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); | |||
vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); | |||
return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); | |||
} | |||
const int sample_nb = 2; | |||
void main(void) | |||
{ | |||
vec2 texcoord = pass_texcoord.xy - vec2(pass_texcoord.z * u_sprite_flip, 0.0); | |||
vec4 color = texture2D(u_texture, texcoord) * pass_color; | |||
//need 130 : ivec2 tex_size = textureSize(u_texture, 0); | |||
if (color.a < 0.9) | |||
{ | |||
bool break_loop = false; | |||
for (int x = -sample_nb; x <= sample_nb; x++) | |||
{ | |||
for (int y = -sample_nb; y <= sample_nb; y++) | |||
{ | |||
if (x != 0 && y != 0) | |||
{ | |||
vec2 new_tc = clamp(texcoord + (vec2(x, y) / 1024.0), vec2(0.0), vec2(1.0)); | |||
vec4 new_col = texture2D(u_texture, new_tc); | |||
//need 130 : vec4 new_col = texelFetch(u_texture, ivec2(tex_size * texcoord) + ivec2(x, y), 0); | |||
if (new_col.a > 0.9) | |||
{ | |||
color = vec4(0.0, 0.0, 0.0, 1.0); | |||
break_loop = true; | |||
//x = sample_nb + 1; | |||
//y = sample_nb + 1; | |||
} | |||
if (break_loop) | |||
break; | |||
} | |||
} | |||
if (break_loop) | |||
break; | |||
} | |||
} | |||
if (color.a < 0.01) | |||
discard; | |||
vec3 hsv = rgb2hsv(color.rgb); | |||
hsv.x = fract(hsv.x + rgb2hsv(pass_color.rgb).x); | |||
gl_FragColor = vec4(hsv2rgb(hsv), color.a); | |||
} | |||
@@ -1,15 +0,0 @@ | |||
include $(top_srcdir)/build/autotools/common.am | |||
if BUILD_SAMPLES | |||
noinst_PROGRAMS = pi poly | |||
endif | |||
pi_SOURCES = pi.cpp | |||
pi_CPPFLAGS = $(AM_CPPFLAGS) | |||
pi_DEPENDENCIES = @LOL_DEPS@ | |||
poly_SOURCES = poly.cpp | |||
poly_CPPFLAGS = $(AM_CPPFLAGS) | |||
poly_DEPENDENCIES = @LOL_DEPS@ | |||
@@ -1,55 +0,0 @@ | |||
// | |||
// Lol Engine — Sample math program: compute Pi | |||
// | |||
// Copyright © 2005—2019 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// This program is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <iostream> | |||
#include <iomanip> | |||
#include <lol/engine.h> | |||
using lol::real; | |||
int main(int argc, char **argv) | |||
{ | |||
UNUSED(argc, argv); | |||
std::cout << std::setprecision(150); | |||
std::cout << " 0: " << real::R_0() << '\n'; | |||
std::cout << " 1: " << real::R_1() << '\n'; | |||
std::cout << "sqrt(2): " << real::R_SQRT2() << '\n'; | |||
std::cout << "sqrt(½): " << real::R_SQRT1_2() << '\n'; | |||
std::cout << " ln(2): " << real::R_LN2() << '\n'; | |||
std::cout << " e: " << real::R_E() << '\n'; | |||
std::cout << " π: " << real::R_PI() << '\n'; | |||
// Gauss-Legendre computation of Pi — six iterations are enough for 150 digits | |||
real a = 1.0, b = real::R_SQRT1_2(), t = 0.25, p = 1.0; | |||
for (int i = 0; i < 6; i++) | |||
{ | |||
real tmp = (a - b) * (real)0.5; | |||
b = sqrt(a * b); | |||
a -= tmp; | |||
t -= p * tmp * tmp; | |||
p += p; | |||
} | |||
real sum = a + b; | |||
sum = sum * sum / ((real)4 * t); | |||
std::cout << " " << sum << '\n'; | |||
return EXIT_SUCCESS; | |||
} | |||
@@ -1,31 +0,0 @@ | |||
// | |||
// Lol Engine — Sample math program: polynomials | |||
// | |||
// Copyright © 2005—2017 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// This program is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <cstdio> | |||
#include <lol/engine.h> | |||
using namespace lol; | |||
int main(int argc, char **argv) | |||
{ | |||
UNUSED(argc, argv); | |||
polynomial<polynomial<float>> p; | |||
return EXIT_SUCCESS; | |||
} | |||
@@ -1,446 +0,0 @@ | |||
// | |||
// Lol Engine — Bullet physics test | |||
// | |||
// Copyright © 2009—2013 Cédric Lecacheur <jordx@free.fr> | |||
// © 2009—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// © 2012—2018 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#pragma once | |||
/* FIXME: this file is pure crap; it's only a test. */ | |||
#include <lol/engine.h> | |||
#include "easymesh/easymesh.h" | |||
#include "physics/easyphysics.h" | |||
#include "physics/easycharactercontroller.h" | |||
#include "physics/easyconstraint.h" | |||
using namespace lol; | |||
using namespace lol::phys; | |||
#if CAT_MODE | |||
#define USE_SPHERE 1 | |||
#else | |||
#define USE_BOX 1 | |||
#define USE_SPHERE 1 | |||
#define USE_CONE 1 | |||
#define USE_CYLINDER 1 | |||
#define USE_CAPSULE 1 | |||
#endif | |||
class PhysicsObject : public WorldEntity | |||
{ | |||
public: | |||
PhysicsObject(Simulation* new_sim, const vec3 &base_location, const quat &base_rotation) | |||
: m_custom_shader(0), | |||
m_ready(false), | |||
m_should_render(true), | |||
m_is_character(false), | |||
m_is_phys(false) | |||
{ | |||
m_physics = new EasyPhysic(this); | |||
//m_mesh.Compile("[sc#ddd afcb 60 1 60 -.1]"); | |||
m_mesh.SetCurColor(Color::white); | |||
m_mesh.AppendFlatChamfBox(vec3(60.f, 1.f, 60.f), -.1f); | |||
vec3 BoxSize = vec3(60.f, 1.f, 60.f); | |||
m_physics->SetCollisionChannel(0, 0xFF); | |||
m_physics->SetShapeToBox(BoxSize); | |||
m_physics->SetMass(.0f); | |||
m_physics->SetTransform(base_location, base_rotation); | |||
m_physics->InitBodyToRigid(true); | |||
m_physics->AddToSimulation(new_sim); | |||
} | |||
PhysicsObject(Simulation* new_sim, const vec3 &base_location, const quat &base_rotation, int dummy) | |||
: m_custom_shader(0), | |||
m_ready(false), | |||
m_should_render(true), | |||
m_is_character(false), | |||
m_is_phys(false) | |||
{ | |||
if (dummy == 1) //for platform purpose | |||
{ | |||
m_physics = new EasyPhysic(this); | |||
m_mesh.Compile("[sc#ddd afcb 20 1 20 -.1]"); | |||
vec3 BoxSize = vec3(20.f, 1.f, 20.f); | |||
m_physics->SetCollisionChannel(0, 0xFF); | |||
m_physics->SetShapeToBox(BoxSize); | |||
m_physics->SetMass(.0f); | |||
m_physics->SetTransform(base_location, base_rotation); | |||
m_physics->InitBodyToRigid(true); | |||
m_physics->AddToSimulation(new_sim); | |||
} | |||
else if (dummy == 2) //for character purpose | |||
{ | |||
m_character = new EasyCharacterController(this); | |||
m_is_character = true; | |||
//m_mesh.Compile("[sc#f00 afcb10 10 10 -.1]"); | |||
m_mesh.Compile( | |||
"[sc#000 scb#000" | |||
//"[sc#aaa scb#aaa" | |||
"[ad8 2 0 rx180 ty-1]" | |||
"[asph8 .5 ty1]" | |||
"[ac32 2 .5 .5 0 0]" | |||
"[asph6 .1 ty.9 tx.5 tz.15]" | |||
"[asph6 .1 ty.9 tx.5 tz-.15]" | |||
"[asph8 .05 sy10 ty.6 tz.5]" | |||
"[asph8 .05 sy10 ty.6 tz-.5]" | |||
"]" | |||
"[sc#fd0 scb#fd0" | |||
"[ac8 .4 .1 0 0 0 ty.25 rz-90 ty.7 tx.5]" | |||
"]" | |||
"[" | |||
"[sc#fff scb#fff" | |||
"[ad8 2 0 rx180 ty-1]" | |||
"[asph8 .5 ty1]" | |||
"[ac32 1.9 .5 .5 0 0]" | |||
"]" | |||
" ty-.1 tx.05]" | |||
); | |||
vec3 BoxSize = vec3(1.f, 2.f, 1.f); | |||
m_character->SetCollisionChannel(0, 0xFF); | |||
m_character->SetShapeToCapsule(BoxSize.x, BoxSize.y); | |||
m_character->SetMass(.0f); | |||
//m_character->SetStepHeight(1.f); | |||
m_character->SetTransform(base_location, base_rotation); | |||
m_character->InitBodyToGhost(); | |||
m_character->AddToSimulation(new_sim); | |||
} | |||
else if (dummy == 3) //for Stairs purpose | |||
{ | |||
m_physics = new EasyPhysic(this); | |||
m_mesh.Compile("[sc#aae afcb4 .25 4 -.01]"); | |||
vec3 BoxSize = vec3(4.f, .25f, 4.f); | |||
m_physics->SetCollisionChannel(0, 0xFF); | |||
m_physics->SetShapeToBox(BoxSize); | |||
m_physics->SetMass(.0f); | |||
m_physics->SetTransform(base_location, base_rotation); | |||
m_physics->InitBodyToRigid(true); | |||
m_physics->AddToSimulation(new_sim); | |||
} | |||
} | |||
PhysicsObject(Simulation* new_sim, float base_mass, const vec3 &base_location, int RandValue = -1) | |||
: m_custom_shader(0), | |||
m_ready(false), | |||
m_should_render(true), | |||
m_is_character(false), | |||
m_is_phys(false) | |||
{ | |||
static array<EasyMesh> MeshRand; | |||
static array<int> MeshLimit; | |||
static array<int> MeshType; | |||
if (!MeshRand.count()) | |||
{ | |||
array<std::string> colors_base = { "#add", "#dad", "#dda", "#daa", "#ada", "#aad" }; | |||
MeshLimit << 0; | |||
#if USE_BOX | |||
{ | |||
array<std::string> colors = colors_base; | |||
while (colors.count()) | |||
{ | |||
EasyMesh m; | |||
vec4 color = Color::C8BppHexString(colors.pop()); | |||
m.SetCurColor(color); | |||
m.AppendFlatChamfBox(vec3(1.7f), .4f); | |||
m.OpenBrace(); | |||
{ | |||
m.SetCurColor(Color::black); | |||
m.ToggleScaleWinding(); | |||
m.AppendFlatChamfBox(vec3(1.9f), .4f); | |||
m.ScaleX(-1.f); | |||
m.ScaleY(-1.f); | |||
m.ScaleZ(-1.f); | |||
} | |||
m.CloseBrace(); | |||
MeshRand << m; | |||
} | |||
} | |||
//MeshRand << "[sc#add afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]"; | |||
//MeshRand << "[sc#dad afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]"; | |||
//MeshRand << "[sc#dda afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]"; | |||
//MeshRand << "[sc#daa afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]"; | |||
//MeshRand << "[sc#ada afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]"; | |||
//MeshRand << "[sc#aad afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]"; | |||
MeshLimit << MeshRand.count(); | |||
MeshType << 0; | |||
#endif //USE_BOX | |||
#if USE_SPHERE | |||
#if CAT_MODE | |||
int nb_sprite = NB_SPRITE; | |||
//SPRITE | |||
vec2 start_point = vec2((float)rand(nb_sprite), (float)rand(nb_sprite)) / vec2((float)nb_sprite); | |||
//vec2(0.f, .0f) / vec2((float)nb_sprite); | |||
vec2 size = vec2(1.f) / vec2((float)nb_sprite); | |||
m_mesh.BD()->SetTexCoordCustomBuild(MeshType::Quad, MeshFaceType::QuadDefault, | |||
start_point, start_point + size); | |||
m_mesh.BD()->SetTexCoordCustomBuild2(MeshType::Quad, MeshFaceType::QuadDefault, | |||
vec2(-PARTICLE_SIZE), vec2(PARTICLE_SIZE)); | |||
MeshRand << "[tpbn tvnc sc#ffff aq 0 0]"; | |||
MeshRand << "[tpbn tvnc sc#faaf aq 0 0]"; | |||
MeshRand << "[tpbn tvnc sc#afaf aq 0 0]"; | |||
MeshRand << "[tpbn tvnc sc#aaff aq 0 0]"; | |||
#else | |||
{ | |||
array<std::string> colors = colors_base; | |||
while (colors.count()) | |||
{ | |||
EasyMesh m; | |||
vec4 color = Color::C8BppHexString(colors.pop()); | |||
m.SetCurColor(color); | |||
m.AppendSphere(1, 2.f); | |||
MeshRand << m; | |||
} | |||
} | |||
//MeshRand << "[sc#add asph1 2]"; | |||
//MeshRand << "[sc#dad asph1 2]"; | |||
//MeshRand << "[sc#dda asph1 2]"; | |||
//MeshRand << "[sc#daa asph1 2]"; | |||
//MeshRand << "[sc#ada asph1 2]"; | |||
//MeshRand << "[sc#aad asph1 2]"; | |||
#endif | |||
MeshLimit << MeshRand.count(); | |||
MeshType << 1; | |||
#endif //USE_SPHERE | |||
#if USE_CONE | |||
{ | |||
array<std::string> colors = colors_base; | |||
while (colors.count()) | |||
{ | |||
EasyMesh m; | |||
vec4 color = Color::C8BppHexString(colors.pop()); | |||
m.SetCurColor(color); | |||
m.SetCurColorB(color); | |||
m.AppendDisc(8, 2.f); | |||
m.RotateX(180.f); | |||
m.TranslateY(-1.f); | |||
m.AppendCylinder(8, 2.f, 2.f, 0.f); | |||
MeshRand << m; | |||
} | |||
} | |||
//MeshRand << "[sc#add scb#add ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]"; | |||
//MeshRand << "[sc#dad scb#dad ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]"; | |||
//MeshRand << "[sc#dda scb#dda ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]"; | |||
//MeshRand << "[sc#daa scb#daa ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]"; | |||
//MeshRand << "[sc#ada scb#ada ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]"; | |||
//MeshRand << "[sc#aad scb#aad ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]"; | |||
MeshLimit << MeshRand.count(); | |||
MeshType << 2; | |||
#endif //USE_CONE | |||
#if USE_CYLINDER | |||
{ | |||
array<std::string> colors = colors_base; | |||
while (colors.count()) | |||
{ | |||
EasyMesh m; | |||
vec4 color = Color::C8BppHexString(colors.pop()); | |||
m.SetCurColor(color); | |||
m.SetCurColorB(color); | |||
m.AppendDisc(8, 2.f); | |||
m.RotateX(180.f); | |||
m.TranslateY(-1.f); | |||
m.MirrorY(); | |||
m.AppendCylinder(8.f, 2.f, 2.f, 2.f); | |||
MeshRand << m; | |||
} | |||
} | |||
//MeshRand << "[sc#add scb#add ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]"; | |||
//MeshRand << "[sc#dad scb#dad ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]"; | |||
//MeshRand << "[sc#dda scb#dda ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]"; | |||
//MeshRand << "[sc#daa scb#daa ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]"; | |||
//MeshRand << "[sc#ada scb#ada ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]"; | |||
//MeshRand << "[sc#aad scb#aad ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]"; | |||
MeshLimit << MeshRand.count(); | |||
MeshType << 3; | |||
#endif //USE_CYLINDER | |||
#if USE_CAPSULE | |||
{ | |||
array<std::string> colors = colors_base; | |||
while (colors.count()) | |||
{ | |||
EasyMesh m; | |||
vec4 color = Color::C8BppHexString(colors.pop()); | |||
m.SetCurColor(color); | |||
m.SetCurColorB(color); | |||
m.AppendCapsule(1, 2.f, 1.f); | |||
MeshRand << m; | |||
} | |||
} | |||
//MeshRand << "[sc#add scb#add acap1 2 1]"; | |||
//MeshRand << "[sc#dad scb#dad acap1 2 1]"; | |||
//MeshRand << "[sc#dda scb#dda acap1 2 1]"; | |||
//MeshRand << "[sc#daa scb#daa acap1 2 1]"; | |||
//MeshRand << "[sc#ada scb#ada acap1 2 1]"; | |||
//MeshRand << "[sc#aad scb#aad acap1 2 1]"; | |||
MeshLimit << MeshRand.count(); | |||
MeshType << 4; | |||
#endif //USE_CAPSULE | |||
} | |||
int RandLimit = RandValue; | |||
if (MeshLimit.count() <= RandValue || RandValue < 0) | |||
RandLimit = rand((int)MeshLimit.count() - 1); | |||
RandValue = rand(MeshLimit[RandLimit], MeshLimit[RandLimit + 1]); | |||
m_physics = new EasyPhysic(this); | |||
//m_mesh.Compile(MeshRand[RandValue]); | |||
m_mesh = MeshRand[RandValue]; | |||
m_mesh.Scale(vec3(OBJ_SIZE)); | |||
vec3 BoxSize = vec3(2.0f) * OBJ_SIZE; | |||
int ColGroup = 1; | |||
switch (MeshType[RandLimit]) | |||
{ | |||
case 0: | |||
{ | |||
m_physics->SetShapeToBox(BoxSize); | |||
ColGroup += 0; | |||
break; | |||
} | |||
case 1: | |||
{ | |||
m_physics->SetShapeToSphere(BoxSize.x); | |||
ColGroup += 1; | |||
break; | |||
} | |||
case 2: | |||
{ | |||
m_physics->SetShapeToCone(BoxSize.x, BoxSize.y); | |||
ColGroup += 2; | |||
break; | |||
} | |||
case 3: | |||
{ | |||
m_physics->SetShapeToCylinder(BoxSize); | |||
ColGroup += 3; | |||
break; | |||
} | |||
case 4: | |||
{ | |||
m_physics->SetShapeToCapsule(BoxSize.x, BoxSize.y); | |||
ColGroup += 4; | |||
break; | |||
} | |||
default: | |||
{ | |||
} | |||
} | |||
m_physics->SetHitRestitution(1.0f); | |||
m_physics->SetCollisionChannel(0, 0xFF); | |||
//m_physics->SetCollisionChannel(ColGroup, (1 << ColGroup)|(1)); | |||
m_physics->SetMass(base_mass); | |||
m_physics->SetTransform(base_location); | |||
m_physics->InitBodyToRigid(); | |||
m_physics->AddToSimulation(new_sim); | |||
} | |||
void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation = lol::quat(lol::mat3(1.0f))) | |||
{ | |||
if (m_is_character) | |||
m_character->SetTransform(base_location, base_rotation); | |||
else | |||
m_physics->SetTransform(base_location, base_rotation); | |||
} | |||
lol::mat4 GetTransform() | |||
{ | |||
if (m_is_character) | |||
return m_character->GetTransform(); | |||
else | |||
return m_physics->GetTransform(); | |||
} | |||
void SetRender(bool should_render) | |||
{ | |||
m_should_render = should_render; | |||
} | |||
void SetCustomShaderData(GpuShaderData* custom_shader) | |||
{ | |||
m_custom_shader = custom_shader; | |||
} | |||
GpuShaderData* GetCustomShaderData() | |||
{ | |||
return m_custom_shader; | |||
} | |||
EasyMesh *GetMesh() { return &m_mesh; } | |||
EasyPhysic *GetPhysic() { return m_physics; } | |||
EasyCharacterController *GetCharacter() { return m_character; } | |||
~PhysicsObject() | |||
{ | |||
} | |||
std::string GetName() const { return "<PhysicsObject>"; } | |||
protected: | |||
virtual void tick_game(float seconds) | |||
{ | |||
WorldEntity::tick_game(seconds); | |||
} | |||
virtual void tick_draw(float seconds, Scene &scene) | |||
{ | |||
WorldEntity::tick_draw(seconds, scene); | |||
#if CAT_MODE | |||
if (!m_is_phys || m_custom_shader) | |||
#endif //CAT_MODE | |||
{ | |||
if (!m_ready) | |||
{ | |||
m_mesh.MeshConvert(); | |||
/* FIXME: m_custom_shader is ignored */ | |||
m_ready = true; | |||
} | |||
else if (m_should_render) | |||
{ | |||
if (m_is_character) | |||
m_mesh.Render(scene, m_character->GetTransform()); | |||
else | |||
m_mesh.Render(scene, m_physics->GetTransform()); | |||
} | |||
} | |||
} | |||
private: | |||
// Base data | |||
EasyMesh m_mesh; | |||
EasyPhysic* m_physics; | |||
EasyCharacterController* m_character; | |||
GpuShaderData* m_custom_shader; | |||
bool m_ready; | |||
bool m_should_render; | |||
bool m_is_character; | |||
bool m_is_phys; /* Only used in CAT_MODE */ | |||
}; | |||
@@ -1,241 +0,0 @@ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net> | |||
// (c) 2009-2013 Cédric Lecacheur <jordx@free.fr> | |||
// (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com> | |||
// This program is free software; you can redistribute it and/or | |||
// modify it under the terms of the Do What The Fuck You Want To | |||
// Public License, Version 2, as published by Sam Hocevar. See | |||
// http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#define USE_LOL_CTRLR_CHARAC | |||
#include <lol/engine.h> | |||
#include <stdio.h> | |||
#include "lolbtphysicsintegration.h" | |||
#include "lolphysics.h" | |||
#include "easycharactercontroller.h" | |||
#include "bulletcharactercontroller.h" | |||
//#include "LinearMath/btIDebugDraw.h" | |||
//#include "BulletCollision/CollisionDispatch/btGhostObject.h" | |||
//#include "BulletCollision/CollisionShapes/btMultiSphereShape.h" | |||
//#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" | |||
//#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" | |||
//#include "BulletCollision/CollisionDispatch/btCollisionWorld.h" | |||
//#include "LinearMath/btDefaultMotionState.h" | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
#ifdef USE_LOL_CTRLR_CHARAC | |||
//When called, will try to remove Character controller from its collision. | |||
bool BulletKinematicCharacterController::RecoverFromPenetration(btCollisionWorld* CollisionWorld) | |||
{ | |||
bool HasPenetration = false; | |||
//Retrieve all pair with us colliding. | |||
CollisionWorld->getDispatcher()->dispatchAllCollisionPairs(m_ghost_object->getOverlappingPairCache(), CollisionWorld->getDispatchInfo(), CollisionWorld->getDispatcher()); | |||
m_current_position = BT2LOLU_VEC3(m_ghost_object->getWorldTransform().getOrigin()); | |||
float MaxPen = .0f; | |||
for (int i = 0; i < m_ghost_object->getOverlappingPairCache()->getNumOverlappingPairs(); i++) | |||
{ | |||
m_manifold_array.resize(0); | |||
//this is the equivalent of the "Touch algorithm". Maybe refactor ? | |||
btBroadphasePair* CollisionPair = &m_ghost_object->getOverlappingPairCache()->getOverlappingPairArray()[i]; | |||
if (CollisionPair->m_algorithm) | |||
CollisionPair->m_algorithm->getAllContactManifolds(m_manifold_array); | |||
for (int j = 0; j < m_manifold_array.size(); ++j) | |||
{ | |||
btPersistentManifold* CurMfold = m_manifold_array[j]; | |||
//Normal direction differs if we're Body0 | |||
float DirSign = CurMfold->getBody0() == m_ghost_object ? -1.f : 1.f; | |||
for (int k = 0; k < CurMfold->getNumContacts(); k++) | |||
{ | |||
const btManifoldPoint& MfPoint = CurMfold->getContactPoint(k); | |||
float Dist = MfPoint.getDistance(); | |||
if (Dist < .0f) | |||
{ | |||
if (Dist < MaxPen) | |||
{ | |||
MaxPen = Dist; | |||
m_touching_normal = BT2LOL_VEC3(MfPoint.m_normalWorldOnB) * DirSign; | |||
} | |||
m_current_position += BT2LOL_VEC3(MfPoint.m_normalWorldOnB) * DirSign * Dist * .2f; | |||
HasPenetration = true; | |||
} | |||
} | |||
} | |||
} | |||
btTransform GObjMx = m_ghost_object->getWorldTransform(); | |||
GObjMx.setOrigin(LOL2BTU_VEC3(m_current_position)); | |||
m_ghost_object->setWorldTransform(GObjMx); | |||
return HasPenetration; | |||
} | |||
//When the Controller hits a wall, we modify the target so the controller will MoveStep along the wall. | |||
void BulletKinematicCharacterController::UpdateTargetOnHit(const vec3& HitNormal, float TangentMag, float NormalMag) | |||
{ | |||
vec3 Movedir = m_target_position - m_current_position; | |||
float MoveLength = (float)length(Movedir); | |||
if (MoveLength > SIMD_EPSILON) | |||
{ | |||
Movedir = normalize(Movedir); | |||
vec3 ReflectDir = normalize(GetReflectedDir(Movedir, HitNormal)); | |||
vec3 ParallelDir = ProjectDirOnNorm(ReflectDir, HitNormal); | |||
vec3 PerpindicularDir = ProjectDirOnNormPerpindicular(ReflectDir, HitNormal); | |||
m_target_position = m_current_position; | |||
if (NormalMag != .0f) | |||
m_target_position += PerpindicularDir * NormalMag * MoveLength; | |||
} | |||
} | |||
//Handles the actual Movement. It actually moves in the 3 dimensions, function name is confusing. | |||
void BulletKinematicCharacterController::DoMove(btCollisionWorld* CollisionWorld, const vec3& MoveStep, float DeltaTime) | |||
{ | |||
// phase 2: forward and strafe | |||
m_target_position = m_current_position + MoveStep; | |||
btTransform SweepStart, SweepEnd; | |||
SweepStart.setIdentity(); | |||
SweepEnd.setIdentity(); | |||
float Fraction = 1.f; | |||
float SqDist = .0f; | |||
if (m_touching_contact && dot(m_normalized_direction, m_touching_normal) > .0f) | |||
UpdateTargetOnHit(m_touching_normal); | |||
//Let's loop on movement, until Movement fraction if below 0.01, which means we've reached our destination. | |||
//Or until we'tried 10 times. | |||
int MaxMoveLoop = 10; | |||
while (Fraction > .01f && MaxMoveLoop-- > 0) | |||
{ | |||
SweepStart.setOrigin(LOL2BTU_VEC3(m_current_position)); | |||
SweepEnd.setOrigin(LOL2BTU_VEC3(m_target_position)); | |||
vec3 SweepDirNeg(m_current_position - m_target_position); | |||
ClosestNotMeConvexResultCallback SweepCallback(m_ghost_object, SweepDirNeg, .0f); | |||
SweepCallback.m_collisionFilterGroup = GetGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup; | |||
SweepCallback.m_collisionFilterMask = GetGhostObject()->getBroadphaseHandle()->m_collisionFilterMask; | |||
//The sweep test is done with an added margin, so we use it and then discard it | |||
float SavedMargin = m_convex_shape->getMargin(); | |||
m_convex_shape->setMargin(SavedMargin + m_added_margin); //Apply Added Margin | |||
if (m_do_gobject_sweep_test) | |||
m_ghost_object->convexSweepTest (m_convex_shape, SweepStart, SweepEnd, SweepCallback, CollisionWorld->getDispatchInfo().m_allowedCcdPenetration); | |||
else | |||
CollisionWorld->convexSweepTest (m_convex_shape, SweepStart, SweepEnd, SweepCallback, CollisionWorld->getDispatchInfo().m_allowedCcdPenetration); | |||
m_convex_shape->setMargin(SavedMargin); //Restore saved margin | |||
Fraction -= SweepCallback.m_closestHitFraction; | |||
if (SweepCallback.hasHit()) | |||
{ | |||
//We moved only a Fraction | |||
float HitDist = (float)length(BT2LOLU_VEC3(SweepCallback.m_hitPointWorld) - m_current_position); | |||
UpdateTargetOnHit(BT2LOL_VEC3(SweepCallback.m_hitNormalWorld)); | |||
vec3 NewDir = m_target_position - m_current_position; | |||
SqDist = sqlength(NewDir); | |||
if (SqDist > SIMD_EPSILON) | |||
{ | |||
NewDir = normalize(NewDir); | |||
//See Quake2: "If velocity is against original velocity, stop ead to avoid tiny oscilations in sloping corners." | |||
if (dot(NewDir, m_normalized_direction) <= .0f) | |||
break; | |||
} | |||
else | |||
break; | |||
} | |||
else //We moved whole way | |||
m_current_position = m_target_position; | |||
} | |||
} | |||
//The PreStep is done in order to recover from any HasPenetration. | |||
void BulletKinematicCharacterController::PreStep(btCollisionWorld* CollisionWorld) | |||
{ | |||
int MaxPenetrationLoop = 0; | |||
m_touching_contact = false; | |||
while (RecoverFromPenetration(CollisionWorld)) | |||
{ | |||
MaxPenetrationLoop++; | |||
m_touching_contact = true; | |||
if (MaxPenetrationLoop > 4) | |||
break; | |||
} | |||
m_current_position = BT2LOLU_VEC3(m_ghost_object->getWorldTransform().getOrigin()); | |||
m_target_position = m_current_position; | |||
} | |||
//And so we step : | |||
//StepUpfirst, then movement, then StepDownon the ground. | |||
void BulletKinematicCharacterController::PlayerStep(btCollisionWorld* CollisionWorld, float DeltaTime) | |||
{ | |||
// quick check... | |||
if (!m_use_walk_direction && m_velocity_time_interval <= .0f) | |||
return; // no motion | |||
// Update fall velocity. | |||
//m_velocity -= m_gravity * DeltaTime; | |||
btTransform NewTransform; | |||
NewTransform = m_ghost_object->getWorldTransform(); | |||
vec3 MoveStep(.0f); | |||
if (m_use_walk_direction) | |||
MoveStep = m_walk_direction; | |||
else | |||
{ | |||
//Still have some time left for moving! | |||
float dtMoving = (DeltaTime < m_velocity_time_interval) ? DeltaTime : m_velocity_time_interval; | |||
m_velocity_time_interval -= DeltaTime; | |||
// how far will we MoveStep while we are moving? | |||
MoveStep = m_walk_direction * dtMoving; | |||
} | |||
//Okay, step ! | |||
DoMove(CollisionWorld, MoveStep, DeltaTime); | |||
//Movement finished, update World transform | |||
NewTransform.setOrigin(LOL2BTU_VEC3(m_current_position)); | |||
m_ghost_object->setWorldTransform(NewTransform); | |||
} | |||
//should MoveStep Jump logic in EasyCC | |||
void BulletKinematicCharacterController::Jump() | |||
{ | |||
if (!CanJump()) | |||
return; | |||
m_vertical_velocity = m_jump_speed; | |||
m_was_jumping = true; | |||
} | |||
#endif // USE_LOL_CTRLR_CHARAC | |||
} /* namespace phys */ | |||
} /* namespace lol */ |
@@ -1,285 +0,0 @@ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net> | |||
// (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com> | |||
// This program is free software; you can redistribute it and/or | |||
// modify it under the terms of the Do What The Fuck You Want To | |||
// Public License, Version 2, as published by Sam Hocevar. See | |||
// http://www.wtfpl.net/ for more details. | |||
// | |||
// | |||
// The BulletCharacterController class | |||
// ------------------ | |||
// This class is a equivalent of btKinematicCharacterController, but more useful for Lol. | |||
// | |||
#if !defined __BULLETCHARACTERCONTROLLER_BULLETCHARACTERCONTROLLER_H__ | |||
#define __BULLETCHARACTERCONTROLLER_BULLETCHARACTERCONTROLLER_H__ | |||
#include <lol/engine.h> | |||
#include "easyphysics.h" | |||
//#include "BulletDynamics\Character\btCharacterControllerInterface.h" | |||
#define USE_LOL_CTRLR_CHARAC | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
#ifdef USE_LOL_CTRLR_CHARAC | |||
//SweepCallback used for Swweep Tests. | |||
class ClosestNotMeConvexResultCallback : public btCollisionWorld::ClosestConvexResultCallback | |||
{ | |||
public: | |||
ClosestNotMeConvexResultCallback(btCollisionObject* NewMe, const vec3& NewUp, float MinSlopeDot) : | |||
btCollisionWorld::ClosestConvexResultCallback(LOL2BTU_VEC3(vec3(.0f)), LOL2BTU_VEC3(vec3(.0f))), | |||
m_me(NewMe), | |||
m_up(NewUp), | |||
m_min_slope_dot(MinSlopeDot) { } | |||
virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& ConvexResult, bool NormalInWorld) | |||
{ | |||
//We hit ourselves, FAIL | |||
if (ConvexResult.m_hitCollisionObject == m_me) | |||
return btScalar(1.f); | |||
vec3 WorldHitNomal(.0f); | |||
if (NormalInWorld) | |||
WorldHitNomal = BT2LOL_VEC3(ConvexResult.m_hitNormalLocal); | |||
else //need to transform Normal into worldspace | |||
{ | |||
btVector3 TmpWorldHitNormal = ConvexResult.m_hitCollisionObject->getWorldTransform().getBasis() * ConvexResult.m_hitNormalLocal; | |||
WorldHitNomal = BT2LOL_VEC3(TmpWorldHitNormal); | |||
} | |||
float DotUp = dot(m_up, WorldHitNomal); | |||
//We hit below the accepted slope_dot, FAIL | |||
if (DotUp < m_min_slope_dot) | |||
return btScalar(1.f); | |||
//Continue to next. | |||
return ClosestConvexResultCallback::addSingleResult(ConvexResult, NormalInWorld); | |||
} | |||
protected: | |||
btCollisionObject* m_me; | |||
const vec3 m_up; | |||
float m_min_slope_dot; | |||
}; | |||
///BulletKinematicCharacterController is an object that supports a sliding motion in a world. | |||
///It uses a ghost object and convex sweep test to test for upcoming collisions. This is combined with discrete collision detection to recover from penetrations. | |||
///Interaction between btKinematicCharacterController and dynamic rigid bodies needs to be explicity implemented by the user. | |||
class BulletKinematicCharacterController : public btActionInterface | |||
{ | |||
public: | |||
BulletKinematicCharacterController(btPairCachingGhostObject* NewGhostObject, btConvexShape* NewConvexShape, float NewStepHeight, int NewUpAxis=1) | |||
{ | |||
m_convex_shape = NewConvexShape; | |||
m_i_up_axis = NewUpAxis; | |||
m_ghost_object = NewGhostObject; | |||
m_step_height = NewStepHeight; | |||
m_added_margin = 0.02f; | |||
m_walk_direction = vec3(.0f, .0f, .0f); | |||
m_do_gobject_sweep_test = true; | |||
m_turn_angle = .0f; | |||
m_use_walk_direction = false; // Should remove walk direction, this doesn't work correctly. | |||
m_velocity_time_interval = .0f; | |||
m_vertical_velocity = .0f; | |||
m_vertical_offset = .0f; | |||
m_f_gravity = 9.8f * 3.f; // 3G acceleration. | |||
m_fall_speed = 55.f; // Terminal velocity of a sky diver in m/s. | |||
m_jump_speed = 10.f; // ? | |||
m_was_on_ground = false; | |||
m_was_jumping = false; | |||
SetMaxSlope(45.f); | |||
} | |||
~BulletKinematicCharacterController() { } | |||
protected: | |||
static vec3* GetUpAxisDirections() | |||
{ | |||
static vec3 sUpAxisDirection[3] = { vec3(1.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f), vec3(0.0f, 0.0f, 1.0f) }; | |||
return sUpAxisDirection; | |||
} | |||
//-------------------------- | |||
//CONVENIENCE FUNCTIONS | |||
//-- | |||
//Returns the reflection Direction of a ray going 'Direction' hitting a surface with Normal 'Normal' from: http://www-cs-students.stanford.edu/~adityagp/final/node3.html | |||
vec3 GetReflectedDir(const vec3& Direction, const vec3& Normal) | |||
{ | |||
return Direction - (2.f * dot(Direction, Normal) * Normal); | |||
} | |||
//Returns the portion of 'direction' that is parallel to 'normal' | |||
vec3 ProjectDirOnNorm(const vec3& Direction, const vec3& Normal) | |||
{ | |||
return Normal * dot(Direction, Normal); | |||
} | |||
//Returns the portion of 'Direction' that is perpindicular to 'Normal' | |||
vec3 ProjectDirOnNormPerpindicular(const vec3& Direction, const vec3& Normal) | |||
{ | |||
return Direction - ProjectDirOnNorm(Direction, Normal); | |||
} | |||
//Returns Ghost Object. -duh- | |||
btPairCachingGhostObject* GetGhostObject() | |||
{ | |||
return m_ghost_object; | |||
} | |||
//"Real" war functions | |||
bool RecoverFromPenetration(btCollisionWorld* CollisionWorld); | |||
void UpdateTargetOnHit(const vec3& hit_normal, float TangentMag = .0f, float NormalMag = 1.f); | |||
void DoMove(btCollisionWorld* CollisionWorld, const vec3& MoveStep, float DeltaTime); | |||
public: | |||
///btActionInterface interface : KEEP IN camelCase | |||
virtual void updateAction(btCollisionWorld* CollisionWorld, float deltaTime) | |||
{ | |||
PreStep(CollisionWorld); | |||
PlayerStep(CollisionWorld, deltaTime); | |||
} | |||
//not in the interface, but called above | |||
void PreStep(btCollisionWorld* CollisionWorld); | |||
void PlayerStep(btCollisionWorld* CollisionWorld, float DeltaTime); | |||
///btActionInterface interface : KEEP IN camelCase | |||
void debugDraw(btIDebugDraw* debugDrawer) { } | |||
void SetUpAxis(int NewAxis) | |||
{ | |||
if (NewAxis < 0) | |||
NewAxis = 0; | |||
if (NewAxis > 2) | |||
NewAxis = 2; | |||
m_i_up_axis = NewAxis; | |||
} | |||
//!!!!!! SHOULD DITCH THAT !!!!!! | |||
//This should probably be called setPositionIncrementPerSimulatorStep. | |||
//This is neither a Direction nor a velocity, but the amount to | |||
//increment the position each simulation iteration, regardless | |||
//of DeltaTime. | |||
//This call will Reset any velocity set by SetVelocityForTimeInterval(). | |||
virtual void SetWalkDirection(const vec3& walkDirection) | |||
{ | |||
m_use_walk_direction = true; | |||
m_walk_direction = walkDirection; | |||
m_normalized_direction = normalize(m_walk_direction); | |||
} | |||
//Caller provides a velocity with which the character should MoveStep for | |||
//the given time period. After the time period, velocity is Reset | |||
//to zero. | |||
//This call will Reset any walk Direction set by SetWalkDirection(). | |||
//Negative time intervals will result in no motion. | |||
virtual void SetVelocityForTimeInterval(const vec3& velocity, float timeInterval) | |||
{ | |||
m_use_walk_direction = false; | |||
m_walk_direction = velocity; | |||
m_normalized_direction = normalize(m_walk_direction); | |||
m_velocity_time_interval = timeInterval; | |||
} | |||
//Usefulness ? | |||
void Reset() { } | |||
void Warp(const vec3& NewOrigin) | |||
{ | |||
btTransform NewTransform; | |||
NewTransform.setIdentity(); | |||
NewTransform.setOrigin(LOL2BTU_VEC3(NewOrigin)); | |||
m_ghost_object->setWorldTransform(NewTransform); | |||
} | |||
//External Setup | |||
//-- | |||
void SetFallSpeed(float NewFallSpeed) { m_fall_speed = NewFallSpeed; } | |||
void SetJumpSpeed(float NewJumpSpeed) { m_jump_speed = NewJumpSpeed; } | |||
void SetMaxJumpHeight(float NewMaxJumpHeight) { m_max_jump_height = NewMaxJumpHeight; } | |||
//Jump logic will go in EasyCC | |||
bool CanJump() const { return OnGround(); } | |||
void Jump(); | |||
//NewGravity functions | |||
void SetGravity(float NewGravity) { m_f_gravity = NewGravity; } | |||
float GetGravity() const { return m_f_gravity; } | |||
//The max slope determines the maximum angle that the controller can walk up. | |||
//The slope angle is measured in radians. | |||
void SetMaxSlope(float NewSlopeRadians) { m_max_slope_radians = NewSlopeRadians; m_max_slope_cosine = lol::cos(NewSlopeRadians); } | |||
float GetMaxSlope() const { return m_max_slope_radians; } | |||
void SetUseGhostSweepTest(bool UseGObjectSweepTest) { m_do_gobject_sweep_test = UseGObjectSweepTest; } | |||
bool OnGround() const { return m_vertical_velocity == .0f && m_vertical_offset == .0f; } | |||
private: | |||
btPairCachingGhostObject* m_ghost_object; | |||
btConvexShape* m_convex_shape; //is also in m_ghost_object, but it needs to be convex, so we store it here to avoid upcast | |||
//keep track of the contact manifolds | |||
btManifoldArray m_manifold_array; | |||
float m_half_height; | |||
float m_velocity_time_interval; | |||
float m_vertical_velocity; | |||
float m_vertical_offset; | |||
float m_fall_speed; | |||
float m_jump_speed; | |||
float m_max_jump_height; | |||
float m_max_slope_radians; // Slope angle that is set (used for returning the exact value) | |||
float m_max_slope_cosine; // Cosine equivalent of m_max_slope_radians (calculated once when set, for optimization) | |||
float m_f_gravity; | |||
float m_turn_angle; | |||
float m_step_height; | |||
float m_added_margin;//@todo: remove this and fix the code | |||
///this is the desired walk Direction, set by the user | |||
vec3 m_walk_direction; | |||
vec3 m_normalized_direction; | |||
//some internal variables | |||
vec3 m_current_position; | |||
float m_current_step_offset; | |||
vec3 m_target_position; | |||
vec3 m_touching_normal; | |||
bool m_touching_contact; | |||
bool m_was_on_ground; | |||
bool m_was_jumping; | |||
bool m_do_gobject_sweep_test; | |||
bool m_use_walk_direction; | |||
int m_i_up_axis; | |||
//--------------------------------------------------------------------- | |||
//NEW INTERNAL VARS | |||
//--------------------------------------------------------------------- | |||
//Gravity in vec3 | |||
vec3 m_gravity; | |||
//Current Velocity | |||
vec3 m_velocity; | |||
}; | |||
#endif // USE_LOL_CTRLR_CHARAC | |||
} /* namespace phys */ | |||
} /* namespace lol */ | |||
#endif /* __BULLETCHARACTERCONTROLLER_BULLETCHARACTERCONTROLLER_H__ */ | |||
@@ -1,150 +0,0 @@ | |||
// | |||
// Lol Engine — Bullet physics test | |||
// | |||
// Copyright © 2009—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// © 2010—2019 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include "lolbtphysicsintegration.h" | |||
#include "lolphysics.h" | |||
#include "easycharactercontroller.h" | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
//------------------------------------------------------------------------- | |||
//EASY_CHARACTER_CONTROLLER | |||
//-- | |||
//Deactivated for Character controller | |||
void EasyCharacterController::InitBodyToRigid(bool ZeroMassIsKinematic) | |||
{ | |||
} | |||
//Return correct Ghost Object | |||
btGhostObject* EasyCharacterController::GetGhostObjectInstance() | |||
{ | |||
return new btPairCachingGhostObject(); | |||
} | |||
//Init to Pair caching ghost object, since Character uses that one. | |||
void EasyCharacterController::InitBodyToGhost() | |||
{ | |||
EasyPhysic::InitBodyToGhost(); | |||
m_pair_caching_object = (btPairCachingGhostObject*)m_ghost_object; | |||
m_ghost_object->setCollisionFlags(btCollisionObject::CF_CHARACTER_OBJECT | m_ghost_object->getCollisionFlags()); | |||
} | |||
//Add Physic object to the simulation | |||
void EasyCharacterController::AddToSimulation(class Simulation* current_simulation) | |||
{ | |||
EasyPhysic::AddToSimulation(current_simulation); | |||
btDiscreteDynamicsWorld* dynamics_world = current_simulation->GetWorld(); | |||
if (dynamics_world) | |||
{ | |||
if (m_character) | |||
delete m_character; | |||
//m_character = new btKinematicCharacterController(m_pair_caching_object, m_convex_shape, m_step_height, m_up_axis); | |||
m_character = new BulletKinematicCharacterController(m_pair_caching_object, m_convex_shape, m_step_height, m_up_axis); | |||
//Deactivate Character controller basic behaviour. | |||
//m_character->setGravity(.0f); | |||
//m_character->setFallSpeed(.0f); | |||
dynamics_world->addAction(m_character); | |||
current_simulation->ObjectRegistration(true, this, Simulation::EEPT_CharacterController); | |||
Ticker::Ref(this); | |||
} | |||
} | |||
//Remove Physic object to the simulation | |||
void EasyCharacterController::RemoveFromSimulation(class Simulation* current_simulation) | |||
{ | |||
EasyPhysic::RemoveFromSimulation(current_simulation); | |||
btDiscreteDynamicsWorld* dynamics_world = current_simulation->GetWorld(); | |||
if (dynamics_world) | |||
{ | |||
if (m_character) | |||
{ | |||
dynamics_world->removeAction(m_character); | |||
current_simulation->ObjectRegistration(false, this, Simulation::EEPT_CharacterController); | |||
Ticker::Unref(this); | |||
} | |||
} | |||
} | |||
void EasyCharacterController::Jump() | |||
{ | |||
m_character->Jump(); | |||
} | |||
//Set movement for this frame | |||
void EasyCharacterController::SetMovementForFrame(vec3 const &MoveQuantity) | |||
{ | |||
m_frame_cached_movement = MoveQuantity; | |||
} | |||
//------------------------------------------------------------------------- | |||
//Base Location/Rotation setup | |||
//-- | |||
void EasyCharacterController::SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation) | |||
{ | |||
if (m_base_is_updating) | |||
{ | |||
m_base_cached_movement = base_location - m_local_to_world[3].xyz; | |||
m_local_to_world = lol::mat4::translate(m_local_to_world[3].xyz) * lol::mat4(base_rotation); | |||
if (m_ghost_object) | |||
m_ghost_object->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(LOL2BT_UNIT * m_local_to_world[3].xyz))); | |||
} | |||
else | |||
EasyPhysic::SetTransform(base_location, base_rotation); | |||
} | |||
//Internal callback when Base transform has changed. | |||
void EasyCharacterController::BaseTransformChanged(const lol::mat4& PreviousMatrix, const lol::mat4& NewMatrix) | |||
{ | |||
m_base_is_updating = true; | |||
EasyPhysic::BaseTransformChanged(PreviousMatrix, NewMatrix); | |||
m_base_is_updating = false; | |||
} | |||
//--- | |||
std::string EasyCharacterController::GetName() | |||
{ | |||
return "<EasyCharacterController>"; | |||
} | |||
//Physic Tick | |||
void EasyCharacterController::tick_game(float seconds) | |||
{ | |||
entity::tick_game(seconds); | |||
//Send final velocity in Bullet | |||
{ | |||
int IterationsNb = (int)(seconds / m_owner_simulation->m_timestep); | |||
float NewSeconds = IterationsNb * m_owner_simulation->m_timestep; | |||
m_character->SetVelocityForTimeInterval((m_base_cached_movement + m_frame_cached_movement) / NewSeconds, NewSeconds); | |||
m_base_cached_movement = vec3(.0f); | |||
} | |||
} | |||
} /* namespace phys */ | |||
} /* namespace lol */ |
@@ -1,108 +0,0 @@ | |||
// | |||
// Lol Engine — Bullet physics test | |||
// | |||
// Copyright © 2009—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// © 2012—2019 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#pragma once | |||
// | |||
// The EasyCharacterController class | |||
// ------------------ | |||
// | |||
//Should try to to make a btKinematicCharacterController for real. | |||
// | |||
#include <lol/engine.h> | |||
#include "easyphysics.h" | |||
#include "bulletcharactercontroller.h" | |||
#include <BulletDynamics/Character/btKinematicCharacterController.h> | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
class EasyCharacterController : public EasyPhysic, | |||
public entity | |||
{ | |||
friend class Simulation; | |||
friend class EasyPhysic; | |||
public: | |||
EasyCharacterController(WorldEntity* NewOwnerEntity) : | |||
EasyPhysic(NewOwnerEntity), | |||
m_pair_caching_object(nullptr), | |||
m_character(nullptr), | |||
m_step_height(.0f), | |||
m_base_is_updating(false), | |||
m_base_cached_movement(vec3(0.f)), | |||
m_frame_cached_movement(vec3(0.f)), | |||
m_walk_velocity(vec3(0.f)), | |||
m_current_velocity(vec3(0.f)) | |||
{ | |||
m_gamegroup = GAMEGROUP_EZP_CHAR_CTRLR; | |||
m_up_axis = 1; | |||
m_gravity = vec3(.0f, -9.81f, .0f); | |||
m_walk_velocity_damping = 0.2f; | |||
} | |||
~EasyCharacterController() | |||
{ | |||
delete m_character; | |||
} | |||
virtual void InitBodyToRigid(bool ZeroMassIsKinematic=false); | |||
virtual void InitBodyToGhost(); | |||
virtual void AddToSimulation(class Simulation* current_simulation); | |||
virtual void RemoveFromSimulation(class Simulation* current_simulation); | |||
virtual void SetMovementForFrame(vec3 const &MoveQuantity); | |||
virtual void Jump(); | |||
virtual void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation); | |||
protected: | |||
virtual void BaseTransformChanged(const lol::mat4& PreviousMatrix, const lol::mat4& NewMatrix); | |||
virtual std::string GetName(); | |||
public: | |||
virtual void tick_game(float seconds); | |||
protected: | |||
virtual btGhostObject* GetGhostObjectInstance(); | |||
btPairCachingGhostObject* m_pair_caching_object; | |||
//btKinematicCharacterController* m_character; | |||
BulletKinematicCharacterController* m_character; | |||
float m_step_height; | |||
int m_up_axis; | |||
bool m_base_is_updating; | |||
vec3 m_base_cached_movement; | |||
vec3 m_frame_cached_movement; | |||
//---- | |||
float m_walk_velocity_damping; | |||
//---- | |||
vec3 m_gravity; | |||
//---- | |||
vec3 m_walk_velocity; | |||
vec3 m_current_velocity; | |||
}; | |||
} /* namespace phys */ | |||
} /* namespace lol */ | |||
@@ -1,43 +0,0 @@ | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include "lolbtphysicsintegration.h" | |||
#include "lolphysics.h" | |||
#include "easyconstraint.h" | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
//------------------------------------------------------------------------- | |||
//EASY_CONSTRAINT | |||
//-- | |||
void EasyConstraint::AddToSimulation(class Simulation* current_simulation) | |||
{ | |||
btDiscreteDynamicsWorld* dynamics_world = current_simulation->GetWorld(); | |||
if (dynamics_world && m_typed_constraint) | |||
{ | |||
dynamics_world->addConstraint(m_typed_constraint, m_disable_a2b_collision); | |||
current_simulation->ObjectRegistration(true, this); | |||
} | |||
} | |||
void EasyConstraint::RemoveFromSimulation(class Simulation* current_simulation) | |||
{ | |||
btDiscreteDynamicsWorld* dynamics_world = current_simulation->GetWorld(); | |||
if (dynamics_world && m_typed_constraint) | |||
{ | |||
dynamics_world->removeConstraint(m_typed_constraint); | |||
current_simulation->ObjectRegistration(false, this); | |||
} | |||
} | |||
} /* namespace phys */ | |||
} /* namespace lol */ | |||
@@ -1,184 +0,0 @@ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright © 2010—2015 Sam Hocevar <sam@hocevar.net> | |||
// © 2009—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// | |||
// This library is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#pragma once | |||
// | |||
// The EasyPhysic class | |||
// ------------------ | |||
// | |||
#include <lol/engine.h> | |||
#include "easyphysics.h" | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
class EasyConstraint | |||
{ | |||
friend class Simulation; | |||
friend class EasyPhysic; | |||
public: | |||
EasyConstraint() : | |||
m_typed_constraint(nullptr), | |||
m_p2p_constraint(nullptr), | |||
m_hinge_constraint(nullptr), | |||
m_slider_constraint(nullptr), | |||
m_cone_twist_constraint(nullptr), | |||
m_6dof_constraint(nullptr), | |||
m_owner_simulation(nullptr), | |||
m_a_physobj(nullptr), | |||
m_b_physobj(nullptr), | |||
m_a_transform(lol::mat4(1.f)), | |||
m_b_transform(lol::mat4(1.f)), | |||
m_using_ref_a(false), | |||
m_disable_a2b_collision(false) | |||
{ | |||
} | |||
~EasyConstraint() | |||
{ | |||
delete m_typed_constraint; | |||
m_p2p_constraint = nullptr; | |||
m_hinge_constraint = nullptr; | |||
m_slider_constraint = nullptr; | |||
m_cone_twist_constraint = nullptr; | |||
m_6dof_constraint = nullptr; | |||
} | |||
void AddToSimulation(class Simulation* current_simulation); | |||
void RemoveFromSimulation(class Simulation* current_simulation); | |||
private: | |||
//check if Init can be done | |||
bool CanProceedWithInit() | |||
{ | |||
if (!m_a_physobj || !m_b_physobj) | |||
return false; | |||
if (!m_a_physobj->m_rigid_body || !m_b_physobj->m_rigid_body) | |||
return false; | |||
return true; | |||
} | |||
//------------------------------------------------------------------------- | |||
//Init constraint functions | |||
//-- | |||
void CustomInitConstraintToPoint2Point() | |||
{ | |||
m_p2p_constraint = new btPoint2PointConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body, | |||
LOL2BT_VEC3(m_a_transform[3].xyz * LOL2BT_UNIT), LOL2BT_VEC3(m_b_transform[3].xyz * LOL2BT_UNIT)); | |||
m_typed_constraint = m_p2p_constraint; | |||
} | |||
void CustomInitConstraintToHinge() | |||
{ | |||
m_hinge_constraint = new btHingeConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body, | |||
btTransform(LOL2BT_QUAT(quat(mat3(m_a_transform))), LOL2BT_VEC3(m_a_transform[3].xyz * LOL2BT_UNIT)), | |||
btTransform(LOL2BT_QUAT(quat(mat3(m_b_transform))), LOL2BT_VEC3(m_b_transform[3].xyz * LOL2BT_UNIT)), | |||
m_using_ref_a); | |||
m_typed_constraint = m_hinge_constraint; | |||
} | |||
void CustomInitConstraintToSlider() | |||
{ | |||
m_slider_constraint = new btSliderConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body, | |||
btTransform(LOL2BT_QUAT(quat(mat3(m_a_transform))), LOL2BT_VEC3(m_a_transform[3].xyz * LOL2BT_UNIT)), | |||
btTransform(LOL2BT_QUAT(quat(mat3(m_b_transform))), LOL2BT_VEC3(m_b_transform[3].xyz * LOL2BT_UNIT)), | |||
m_using_ref_a); | |||
m_typed_constraint = m_slider_constraint; | |||
} | |||
void CustomInitConstraintToConeTwist() | |||
{ | |||
m_cone_twist_constraint = new btConeTwistConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body, | |||
btTransform(LOL2BT_QUAT(quat(mat3(m_a_transform))), LOL2BT_VEC3(m_a_transform[3].xyz * LOL2BT_UNIT)), | |||
btTransform(LOL2BT_QUAT(quat(mat3(m_b_transform))), LOL2BT_VEC3(m_b_transform[3].xyz * LOL2BT_UNIT))); | |||
m_typed_constraint = m_cone_twist_constraint; | |||
} | |||
void CustomInitConstraintTo6Dof() | |||
{ | |||
m_6dof_constraint = new btGeneric6DofConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body, | |||
btTransform(LOL2BT_QUAT(quat(mat3(m_a_transform))), LOL2BT_VEC3(m_a_transform[3].xyz * LOL2BT_UNIT)), | |||
btTransform(LOL2BT_QUAT(quat(mat3(m_b_transform))), LOL2BT_VEC3(m_b_transform[3].xyz * LOL2BT_UNIT)), | |||
m_using_ref_a); | |||
m_typed_constraint = m_6dof_constraint; | |||
} | |||
btTypedConstraint* m_typed_constraint; | |||
btPoint2PointConstraint* m_p2p_constraint; | |||
btHingeConstraint* m_hinge_constraint; | |||
btSliderConstraint* m_slider_constraint; | |||
btConeTwistConstraint* m_cone_twist_constraint; | |||
btGeneric6DofConstraint* m_6dof_constraint; | |||
public: | |||
void InitConstraintToPoint2Point() { if (CanProceedWithInit()) CustomInitConstraintToPoint2Point(); } | |||
void InitConstraintToHinge() { if (CanProceedWithInit()) CustomInitConstraintToHinge(); } | |||
void InitConstraintToSlider() { if (CanProceedWithInit()) CustomInitConstraintToSlider(); } | |||
void InitConstraintToConeTwist() { if (CanProceedWithInit()) CustomInitConstraintToConeTwist(); } | |||
void InitConstraintTo6Dof() { if (CanProceedWithInit()) CustomInitConstraintTo6Dof(); } | |||
//Set given physic object to the proper slot. | |||
void SetPhysObjA(EasyPhysic* NewPhysObj, lol::mat4 NewTransform) { SetPhysObj(false, NewPhysObj, NewTransform); } | |||
void SetPhysObjB(EasyPhysic* NewPhysObj, lol::mat4 NewTransform) { SetPhysObj(true, NewPhysObj, NewTransform); } | |||
void SetPhysObj(bool SetToB, EasyPhysic* NewPhysObj, lol::mat4 NewTransform) | |||
{ | |||
if (SetToB) | |||
{ | |||
m_b_physobj = NewPhysObj; | |||
m_b_transform = NewTransform; | |||
} | |||
else | |||
{ | |||
m_a_physobj = NewPhysObj; | |||
m_a_transform = NewTransform; | |||
} | |||
} | |||
//Set whether or not the physic engine should use the A object as the reference (most constraint transform are local). | |||
void SetRefAsA(bool NewUseRefA) | |||
{ | |||
m_using_ref_a = NewUseRefA; | |||
} | |||
//Set whether or not to disable the collision between the bodies | |||
void DisableCollisionBetweenObjs(bool DisableCollision) | |||
{ | |||
m_disable_a2b_collision = DisableCollision; | |||
} | |||
private: | |||
Simulation* m_owner_simulation; | |||
EasyPhysic* m_a_physobj; | |||
EasyPhysic* m_b_physobj; | |||
lol::mat4 m_a_transform; | |||
lol::mat4 m_b_transform; | |||
bool m_using_ref_a; | |||
bool m_disable_a2b_collision; | |||
}; | |||
} /* namespace phys */ | |||
} /* namespace lol */ | |||
@@ -1,430 +0,0 @@ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright © 2010—2015 Sam Hocevar <sam@hocevar.net> | |||
// © 2009—2013 Cédric Lecacheur <jordx@free.fr> | |||
// © 2009—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// | |||
// This library is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include "lolbtphysicsintegration.h" | |||
#include "lolphysics.h" | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
//------------------------------------------------------------------------- | |||
//EASY_PHYSIC | |||
//-- | |||
EasyPhysic::EasyPhysic(WorldEntity* NewOwnerEntity) : | |||
m_collision_object(nullptr), | |||
m_ghost_object(nullptr), | |||
m_rigid_body(nullptr), | |||
m_local_inertia(btVector3(.0f, .0f, .0f)), | |||
m_collision_shape(nullptr), | |||
m_convex_shape(nullptr), | |||
m_motion_state(nullptr), | |||
m_mass(.0f), | |||
m_hit_restitution(.0f), | |||
m_collision_group(1), | |||
m_collision_mask(1), | |||
m_owner_entity(NewOwnerEntity), | |||
m_owner_simulation(nullptr), | |||
m_base_physic(nullptr) | |||
{ | |||
} | |||
EasyPhysic::~EasyPhysic() | |||
{ | |||
m_rigid_body = nullptr; | |||
delete m_collision_object; | |||
delete m_collision_shape; | |||
delete m_motion_state; | |||
} | |||
//------------------------------------------------------------------------- | |||
//Set Shape functions | |||
//-- | |||
void EasyPhysic::SetShapeTo(btCollisionShape* collision_shape) | |||
{ | |||
bool bReinitToRigidBody = false; | |||
if (m_rigid_body) | |||
{ | |||
bReinitToRigidBody = true; | |||
delete m_rigid_body; | |||
} | |||
if (m_collision_shape) | |||
delete m_collision_shape; | |||
m_collision_shape = collision_shape; | |||
if (bReinitToRigidBody) | |||
InitBodyToRigid(); | |||
} | |||
//Box Shape support | |||
void EasyPhysic::SetShapeToBox(lol::vec3& box_size) | |||
{ | |||
vec3 new_box_size = box_size * LOL2BT_UNIT * LOL2BT_SIZE; | |||
m_convex_shape = new btBoxShape(LOL2BT_VEC3(new_box_size)); | |||
SetShapeTo(m_convex_shape); | |||
} | |||
void EasyPhysic::SetShapeToSphere(float radius) | |||
{ | |||
m_convex_shape = new btSphereShape(radius * LOL2BT_UNIT * LOL2BT_SIZE); | |||
SetShapeTo(m_convex_shape); | |||
} | |||
void EasyPhysic::SetShapeToCone(float radius, float height) | |||
{ | |||
m_convex_shape = new btConeShape( radius * LOL2BT_UNIT, | |||
height * LOL2BT_UNIT); | |||
SetShapeTo(m_convex_shape); | |||
} | |||
void EasyPhysic::SetShapeToCylinder(lol::vec3& cyl_size) | |||
{ | |||
vec3 new_cyl_size = cyl_size * LOL2BT_UNIT; | |||
new_cyl_size.y *= LOL2BT_SIZE; | |||
m_convex_shape = new btCylinderShape(LOL2BT_VEC3(new_cyl_size)); | |||
SetShapeTo(m_convex_shape); | |||
} | |||
void EasyPhysic::SetShapeToCapsule(float radius, float height) | |||
{ | |||
m_convex_shape = new btCapsuleShape(radius * LOL2BT_UNIT * LOL2BT_SIZE, | |||
height * LOL2BT_UNIT * LOL2BT_SIZE); | |||
SetShapeTo(m_convex_shape); | |||
} | |||
//------------------------------------------------------------------------- | |||
//Base Location/Rotation setup | |||
//-- | |||
//Getter | |||
mat4 EasyPhysic::GetTransform() | |||
{ | |||
m_local_to_world = lol::mat4(1.0f); | |||
if (m_rigid_body && m_motion_state) | |||
{ | |||
btTransform CurTransform; | |||
m_motion_state->getWorldTransform(CurTransform); | |||
CurTransform.getOpenGLMatrix(&m_local_to_world[0][0]); | |||
} | |||
else if (m_collision_object) | |||
m_collision_object->getWorldTransform().getOpenGLMatrix(&m_local_to_world[0][0]); | |||
return m_local_to_world; | |||
} | |||
//Setter | |||
void EasyPhysic::SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation) | |||
{ | |||
lol::mat4 PreviousMatrix = m_local_to_world; | |||
m_local_to_world = lol::mat4::translate(base_location) * lol::mat4(base_rotation); | |||
if (m_ghost_object) | |||
m_ghost_object->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(LOL2BT_UNIT * base_location))); | |||
else | |||
{ | |||
if (m_motion_state) | |||
m_motion_state->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(LOL2BT_UNIT * base_location))); | |||
else | |||
m_motion_state = new btDefaultMotionState(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(LOL2BT_UNIT * base_location))); | |||
} | |||
for (int i = 0; i < m_based_physic_list.count(); i++) | |||
{ | |||
if (m_based_physic_list[i]) | |||
m_based_physic_list[i]->BaseTransformChanged(PreviousMatrix, m_local_to_world); | |||
else | |||
m_based_physic_list.remove(i--); | |||
} | |||
} | |||
//Internal callback when Base transform has changed. | |||
void EasyPhysic::BaseTransformChanged(const lol::mat4& PreviousMatrix, const lol::mat4& NewMatrix) | |||
{ | |||
mat4 PreviousMatrixLoc = ((m_base_lock_location)?(PreviousMatrix):(lol::mat4::translate(PreviousMatrix[3].xyz))); | |||
mat4 PreviousMatrixRot = ((m_base_lock_rotation)?(lol::mat4(lol::quat(lol::mat3(PreviousMatrix)))):(lol::mat4(1.f))); | |||
mat4 NewMatrixLoc = ((m_base_lock_location)?(NewMatrix):(lol::mat4::translate(NewMatrix[3].xyz))); | |||
mat4 NewMatrixRot = ((m_base_lock_rotation)?(lol::mat4(lol::quat(lol::mat3(NewMatrix)))):(lol::mat4(1.f))); | |||
if (m_ghost_object || (m_rigid_body->getCollisionFlags() & btCollisionObject::CF_KINEMATIC_OBJECT)) | |||
{ | |||
mat4 ThisMatrixLoc = NewMatrixLoc * inverse(PreviousMatrixLoc) * lol::mat4::translate(m_local_to_world[3].xyz); | |||
mat4 ThisMatrixRot = NewMatrixRot * inverse(PreviousMatrixRot) * lol::mat4(lol::quat(lol::mat3(m_local_to_world))); | |||
SetTransform(ThisMatrixLoc[3].xyz, lol::quat(lol::mat3(ThisMatrixRot))); | |||
} | |||
} | |||
//------------------------------------------------------------------------- | |||
//Mass related functions | |||
//-- | |||
//Set Mass functions | |||
void EasyPhysic::SetMass(float mass) | |||
{ | |||
m_mass = mass; | |||
if (m_rigid_body) | |||
{ | |||
SetLocalInertia(m_mass); | |||
m_rigid_body->setMassProps(m_mass, m_local_inertia); | |||
} | |||
} | |||
//------------------------------------------------------------------------- | |||
//Hit restitution functions | |||
//-- | |||
//Set Hit Restitution functions | |||
void EasyPhysic::SetHitRestitution(float hit_restitution) | |||
{ | |||
m_hit_restitution = hit_restitution; | |||
if (m_rigid_body) | |||
{ | |||
m_rigid_body->setRestitution(m_hit_restitution); | |||
} | |||
} | |||
//------------------------------------------------------------------------- | |||
//Final conversion pass functions : Body related | |||
//-- | |||
//Init to rigid body | |||
void EasyPhysic::InitBodyToRigid(bool SetToKinematic) | |||
{ | |||
if (m_collision_object) | |||
delete m_collision_object; | |||
if (!m_motion_state) | |||
SetTransform(vec3(.0f)); | |||
btRigidBody::btRigidBodyConstructionInfo NewInfos(m_mass, m_motion_state, m_collision_shape, m_local_inertia); | |||
NewInfos.m_restitution = m_hit_restitution; | |||
m_rigid_body = new btRigidBody(NewInfos); | |||
m_collision_object = m_rigid_body; | |||
m_collision_object->setUserPointer(this); | |||
if (m_mass == .0f) | |||
{ | |||
if (SetToKinematic) | |||
{ | |||
m_rigid_body->setActivationState(DISABLE_DEACTIVATION); | |||
m_rigid_body->setCollisionFlags(m_rigid_body->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT); | |||
} | |||
} | |||
else | |||
SetMass(m_mass); | |||
} | |||
//Return correct Ghost Object | |||
btGhostObject* EasyPhysic::GetGhostObjectInstance() | |||
{ | |||
return new btGhostObject(); | |||
} | |||
//Init to Ghost object, for Overlap/Sweep Test/Touching logic | |||
void EasyPhysic::InitBodyToGhost() | |||
{ | |||
if (m_collision_object) | |||
delete m_collision_object; | |||
m_ghost_object = GetGhostObjectInstance(); | |||
m_ghost_object->setCollisionShape(m_collision_shape); | |||
m_collision_object = m_ghost_object; | |||
m_collision_object->setUserPointer(this); | |||
SetTransform(m_local_to_world[3].xyz, lol::quat(lol::mat3(m_local_to_world))); | |||
m_ghost_object->setCollisionFlags(m_ghost_object->getCollisionFlags()); | |||
} | |||
//------------- | |||
//Touch logic | |||
//------------- | |||
// btManifoldArray manifoldArray; | |||
// btBroadphasePairArray& pairArray = ghostObject->getOverlappingPairCache()->getOverlappingPairArray(); | |||
// int numPairs = pairArray.size(); | |||
// for (int i=0;i<numPairs;i++) | |||
// { | |||
// manifoldArray.clear(); | |||
// const btBroadphasePair& pair = pairArray[i]; | |||
// | |||
// //unless we manually perform collision detection on this pair, the contacts are in the dynamics world paircache: | |||
// btBroadphasePair* collisionPair = dynamicsWorld->getPairCache()->findPair(pair.m_pProxy0,pair.m_pProxy1); | |||
// if (!collisionPair) | |||
// continue; | |||
// if (collisionPair->m_algorithm) | |||
// collisionPair->m_algorithm->getAllContactManifolds(manifoldArray); | |||
// for (int j=0;j<manifoldArray.size();j++) | |||
// { | |||
// btPersistentManifold* manifold = manifoldArray[j]; | |||
// btScalar directionSign = manifold->getBody0() == m_ghostObject ? btScalar(-1.0) : btScalar(1.0); | |||
// for (int p=0;p<manifold->getNumContacts();p++) | |||
// { | |||
// const btManifoldPoint&pt = manifold->getContactPoint(p); | |||
// if (pt.getDistance()<0.f) | |||
//{ | |||
// const btVector3& ptA = pt.getPositionWorldOnA(); | |||
// const btVector3& ptB = pt.getPositionWorldOnB(); | |||
// const btVector3& normalOnB = pt.m_normalWorldOnB; | |||
// /// work here | |||
//} | |||
// } | |||
// } | |||
// } | |||
//Add Physic object to the simulation | |||
void EasyPhysic::AddToSimulation(class Simulation* current_simulation) | |||
{ | |||
btDiscreteDynamicsWorld* dynamics_world = current_simulation->GetWorld(); | |||
if (dynamics_world) | |||
{ | |||
if (m_ghost_object) | |||
{ | |||
dynamics_world->addCollisionObject(m_ghost_object, m_collision_group, m_collision_mask); | |||
current_simulation->ObjectRegistration(true, this, Simulation::EEPT_Ghost); | |||
} | |||
else if (m_rigid_body) | |||
{ | |||
dynamics_world->addRigidBody(m_rigid_body, m_collision_group, m_collision_mask); | |||
if (m_mass != .0f) | |||
current_simulation->ObjectRegistration(true, this, Simulation::EEPT_Dynamic); | |||
else | |||
current_simulation->ObjectRegistration(true, this, Simulation::EEPT_Static); | |||
} | |||
else | |||
{ | |||
dynamics_world->addCollisionObject(m_collision_object, m_collision_group, m_collision_mask); | |||
current_simulation->ObjectRegistration(true, this, Simulation::EEPT_CollisionObject); | |||
} | |||
} | |||
} | |||
//Remove Physic object to the simulation | |||
void EasyPhysic::RemoveFromSimulation(class Simulation* current_simulation) | |||
{ | |||
btDiscreteDynamicsWorld* dynamics_world = current_simulation->GetWorld(); | |||
if (dynamics_world) | |||
{ | |||
if (m_rigid_body) | |||
{ | |||
dynamics_world->removeRigidBody(m_rigid_body); | |||
if (m_mass != .0f) | |||
current_simulation->ObjectRegistration(false, this, Simulation::EEPT_Dynamic); | |||
else | |||
current_simulation->ObjectRegistration(false, this, Simulation::EEPT_Static); | |||
} | |||
else | |||
{ | |||
dynamics_world->removeCollisionObject(m_collision_object); | |||
if (m_ghost_object) | |||
current_simulation->ObjectRegistration(false, this, Simulation::EEPT_Ghost); | |||
current_simulation->ObjectRegistration(false, this, Simulation::EEPT_CollisionObject); | |||
} | |||
} | |||
} | |||
//------------------------------------------------------------------------- | |||
//Force/Impulse functions | |||
//-- | |||
void EasyPhysic::AddImpulse(const lol::vec3& impulse) | |||
{ | |||
if (m_rigid_body) | |||
m_rigid_body->applyCentralImpulse(LOL2BT_VEC3(impulse)); | |||
} | |||
void EasyPhysic::AddImpulse(const lol::vec3& impulse, const lol::vec3& rel_pos) | |||
{ | |||
if (m_rigid_body) | |||
m_rigid_body->applyImpulse(LOL2BT_VEC3(impulse), LOL2BTU_VEC3(rel_pos)); | |||
} | |||
void EasyPhysic::AddImpulseTorque(const lol::vec3& torque) | |||
{ | |||
if (m_rigid_body) | |||
m_rigid_body->applyTorqueImpulse(LOL2BT_VEC3(torque)); | |||
} | |||
//-- | |||
void EasyPhysic::AddForce(const lol::vec3& force) | |||
{ | |||
if (m_rigid_body) | |||
m_rigid_body->applyCentralForce(LOL2BT_VEC3(force)); | |||
} | |||
void EasyPhysic::AddForce(const lol::vec3& force, const lol::vec3& rel_pos) | |||
{ | |||
if (m_rigid_body) | |||
m_rigid_body->applyForce(LOL2BT_VEC3(force), LOL2BTU_VEC3(rel_pos)); | |||
} | |||
void EasyPhysic::AddForceTorque(const lol::vec3& torque) | |||
{ | |||
if (m_rigid_body) | |||
m_rigid_body->applyTorque(LOL2BT_VEC3(torque)); | |||
} | |||
//------------------------------------------------------------------------- | |||
//Movements getter | |||
//-- | |||
lol::vec3 EasyPhysic::GetLinearVelocity() const | |||
{ | |||
if (m_rigid_body) | |||
return BT2LOL_VEC3(m_rigid_body->getLinearVelocity()); | |||
return lol::vec3(.0f); | |||
} | |||
lol::vec3 EasyPhysic::GetLinearForce() const | |||
{ | |||
if (m_rigid_body) | |||
return BT2LOL_VEC3(m_rigid_body->getTotalForce()); | |||
return lol::vec3(.0f); | |||
} | |||
lol::vec3 EasyPhysic::GetAngularVelocity() const | |||
{ | |||
if (m_rigid_body) | |||
return BT2LOL_VEC3(m_rigid_body->getAngularVelocity()); | |||
return lol::vec3(.0f); | |||
} | |||
lol::vec3 EasyPhysic::GetAngularForce() const | |||
{ | |||
if (m_rigid_body) | |||
return BT2LOL_VEC3(m_rigid_body->getTotalTorque()); | |||
return lol::vec3(.0f); | |||
} | |||
//Set Local Inertia | |||
void EasyPhysic::SetLocalInertia(float mass) | |||
{ | |||
if (mass != .0f) | |||
m_collision_shape->calculateLocalInertia(mass, m_local_inertia); | |||
else | |||
m_local_inertia = btVector3(.0f, .0f, .0f); | |||
} | |||
} /* namespace phys */ | |||
} /* namespace lol */ |
@@ -1,159 +0,0 @@ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright © 2010—2015 Sam Hocevar <sam@hocevar.net> | |||
// © 2009—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// | |||
// This library is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#pragma once | |||
// | |||
// The EasyPhysic class | |||
// ------------------ | |||
// | |||
#include <lol/engine.h> | |||
#include <btBulletDynamicsCommon.h> | |||
#include <btBulletCollisionCommon.h> | |||
#include <BulletCollision/CollisionDispatch/btGhostObject.h> | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
class EasyPhysic | |||
{ | |||
friend class Simulation; | |||
friend class EasyConstraint; | |||
public: | |||
EasyPhysic(WorldEntity* NewOwnerEntity); | |||
~EasyPhysic(); | |||
virtual void SetShapeToBox(lol::vec3& box_size); | |||
virtual void SetShapeToSphere(float radius); | |||
virtual void SetShapeToCone(float radius, float height); | |||
virtual void SetShapeToCylinder(lol::vec3& cyl_size); | |||
virtual void SetShapeToCapsule(float radius, float height); | |||
virtual bool CanChangeCollisionChannel() { return (m_rigid_body == nullptr); } | |||
virtual mat4 GetTransform(); | |||
virtual void SetTransform(const vec3& base_location, const quat& base_rotation = quat(mat3(1.0f))); | |||
protected: | |||
virtual void BaseTransformChanged(const mat4& PreviousMatrix, const mat4& NewMatrix); | |||
public: | |||
virtual void SetMass(float mass); | |||
virtual float GetMass() { return m_mass; } | |||
virtual void SetHitRestitution(float hit_restitution); | |||
virtual void InitBodyToRigid(bool ZeroMassIsKinematic=false); | |||
virtual void InitBodyToGhost(); | |||
virtual void AddToSimulation(class Simulation* current_simulation); | |||
virtual void RemoveFromSimulation(class Simulation* current_simulation); | |||
//Force/Impulse functions | |||
virtual void AddImpulse(const lol::vec3& impulse); | |||
virtual void AddImpulse(const lol::vec3& impulse, const lol::vec3& rel_pos); | |||
virtual void AddImpulseTorque(const lol::vec3& torque); | |||
virtual void AddForce(const lol::vec3& force); | |||
virtual void AddForce(const lol::vec3& force, const lol::vec3& rel_pos); | |||
virtual void AddForceTorque(const lol::vec3& torque); | |||
//Movements getter | |||
lol::vec3 GetLinearVelocity() const; | |||
lol::vec3 GetLinearForce() const; | |||
lol::vec3 GetAngularVelocity() const; | |||
lol::vec3 GetAngularForce() const; | |||
protected: | |||
virtual void SetLocalInertia(float mass); | |||
virtual void SetShapeTo(btCollisionShape* collision_shape); | |||
virtual btGhostObject* GetGhostObjectInstance(); | |||
btCollisionObject* m_collision_object; | |||
btGhostObject* m_ghost_object; | |||
btRigidBody* m_rigid_body; | |||
btVector3 m_local_inertia; | |||
btCollisionShape* m_collision_shape; | |||
btConvexShape* m_convex_shape; | |||
btMotionState* m_motion_state; | |||
public: | |||
//Sets the collision Group & Mask. | |||
//Mask can change at runtime, not group ! | |||
virtual bool SetCollisionChannel(int NewGroup, int NewMask) | |||
{ | |||
if (CanChangeCollisionChannel()) | |||
{ | |||
m_collision_group = (1 << NewGroup); | |||
m_collision_mask = NewMask; | |||
return true; | |||
} | |||
return false; | |||
} | |||
int GetCollisionGroup() { return m_collision_group; } | |||
int GetCollisionMask() { return m_collision_mask; } | |||
//Base/Attachment logic | |||
virtual void AttachTo(EasyPhysic* NewBase, bool NewBaseLockLocation = true, bool NewBaseLockRotation = true) | |||
{ | |||
if (NewBase == this || (NewBase && NewBase->m_base_physic == this)) | |||
return; | |||
if (NewBase) | |||
{ | |||
bool bAlreadyExists = false; | |||
for (int i = 0; i < NewBase->m_based_physic_list.count(); ++i) | |||
if (NewBase->m_based_physic_list[i] == this) | |||
bAlreadyExists = true; | |||
if (!bAlreadyExists) | |||
NewBase->m_based_physic_list << this; | |||
m_base_physic = NewBase; | |||
m_base_lock_location = NewBaseLockLocation; | |||
m_base_lock_rotation = NewBaseLockRotation; | |||
} | |||
else if (m_base_physic) | |||
{ | |||
for (int i = 0; i < m_base_physic->m_based_physic_list.count(); ++i) | |||
if (m_base_physic->m_based_physic_list[i] == this) | |||
m_base_physic->m_based_physic_list.remove(i--); | |||
m_base_physic = nullptr; | |||
} | |||
} | |||
protected: | |||
lol::mat4 m_local_to_world; | |||
float m_mass; | |||
float m_hit_restitution; | |||
int m_collision_group; | |||
int m_collision_mask; | |||
WorldEntity* m_owner_entity; | |||
Simulation* m_owner_simulation; | |||
//Base/Attachment logic | |||
array<EasyPhysic*> m_based_physic_list; //List of objects based on this : this object moves, its based object MoveStep with it. | |||
EasyPhysic* m_base_physic; //Base for this object : The base moves, the object moves with it. | |||
bool m_base_lock_location; //when this is TRUE, location moves with rotation change. | |||
bool m_base_lock_rotation; //when this is TRUE, rotation moves with rotation change. | |||
//Touch logic | |||
array<EasyPhysic*> m_touching_physic; //Maintained by ghost objects | |||
}; | |||
} /* namespace phys */ | |||
} /* namespace lol */ | |||
@@ -1,47 +0,0 @@ | |||
// | |||
// Lol Engine | |||
// | |||
// Copyright © 2009—2019 Sam Hocevar <sam@hocevar.net> | |||
// © 2010—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// | |||
// This library is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#pragma once | |||
// | |||
// Bullet Physics integration in Lol | |||
// --------------------------------- | |||
// | |||
namespace lol | |||
{ | |||
// Override Gamegroups names for Physic-usage | |||
// "_ENT_" means that this is a group for Entities that use EasyPhysic primitives. | |||
// "_EZP_" means that this is a group for EasyPhysic primitives. | |||
#define GAMEGROUP_EZP_CHAR_CTRLR tickable::group::game::other_2 | |||
#define GAMEGROUP_SIMULATION tickable::group::game::other_3 | |||
#define LOL2BT_UNIT 1.0f | |||
#define BT2LOL_UNIT 1.0f | |||
#define LOL2BT_SIZE 0.5f | |||
#define BT2LOL_SIZE 2.0f | |||
#define LOL2BT_VEC3(v) btVector3((v).x, (v).y, (v).z) | |||
#define BT2LOL_VEC3(v) lol::vec3(v.getX(), v.getY(), v.getZ()) | |||
// Same as above with Unit taken into account | |||
#define LOL2BTU_VEC3(v) (LOL2BT_VEC3(v) * LOL2BT_UNIT) | |||
#define BT2LOLU_VEC3(v) (BT2LOL_VEC3(v) * BT2LOL_UNIT) | |||
#define LOL2BT_QUAT(q) btQuaternion((q).x, (q).y, (q).z, (q).w) | |||
#define BT2LOL_QUAT(q) lol::quat((q).getW(), BT2LOL_VEC3((q).getAxis()) | |||
} /* namespace lol */ | |||
@@ -1,425 +0,0 @@ | |||
// | |||
// Lol Engine — Bullet physics test | |||
// | |||
// Copyright © 2009—2013 Benjamin “Touky” Huet <huet.benjamin@gmail.com> | |||
// © 2012—2019 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#pragma once | |||
#include <cstring> | |||
#include <btBulletDynamicsCommon.h> | |||
#include <btBulletCollisionCommon.h> | |||
#include <BulletDynamics/Character/btKinematicCharacterController.h> | |||
#include "lolbtphysicsintegration.h" | |||
#include "easyphysics.h" | |||
#include "easyconstraint.h" | |||
namespace lol | |||
{ | |||
namespace phys | |||
{ | |||
enum eRaycastType | |||
{ | |||
ERT_Closest, | |||
ERT_AllHit, | |||
ERT_AnyHit, //Will stop at the first hit. Hit data are supposed to be irrelevant | |||
ERT_MAX | |||
}; | |||
struct RayCastResult | |||
{ | |||
RayCastResult(int CollisionFilterGroup=1, int CollisionFilterMask=(0xFF)) | |||
{ | |||
memset(this, 0, sizeof(RayCastResult)); | |||
m_collision_filter_group = CollisionFilterGroup; | |||
m_collision_filter_mask = CollisionFilterMask; | |||
} | |||
void Reset() | |||
{ | |||
m_collider_list.clear(); | |||
m_hit_normal_list.clear(); | |||
m_hit_point_list.clear(); | |||
m_hit_fraction_list.clear(); | |||
} | |||
array<EasyPhysic*> m_collider_list; | |||
array<vec3> m_hit_normal_list; | |||
array<vec3> m_hit_point_list; | |||
array<float> m_hit_fraction_list; | |||
short int m_collision_filter_group; | |||
short int m_collision_filter_mask; | |||
unsigned int m_flags; //??? | |||
}; | |||
class Simulation : public entity | |||
{ | |||
public: | |||
Simulation() : | |||
m_broadphase(0), | |||
m_collision_configuration(0), | |||
m_dispatcher(0), | |||
m_solver(0), | |||
m_dynamics_world(0), | |||
m_timestep(1.f/60.f) | |||
{ | |||
m_gamegroup = GAMEGROUP_SIMULATION; | |||
} | |||
~Simulation() | |||
{ | |||
Exit(); | |||
} | |||
std::string GetName() const { return "<Simulation>"; } | |||
public: | |||
void Init() | |||
{ | |||
// Build the broadphase | |||
if (1) | |||
{ | |||
m_Sweep_broadphase = new btAxisSweep3(LOL2BT_VEC3(m_world_min), LOL2BT_VEC3(m_world_max)); | |||
m_Sweep_broadphase->getOverlappingPairCache()->setInternalGhostPairCallback(new btGhostPairCallback()); | |||
m_broadphase = m_Sweep_broadphase; | |||
} | |||
else | |||
m_broadphase = new btDbvtBroadphase(); | |||
// Set up the collision configuration and dispatcher | |||
m_collision_configuration = new btDefaultCollisionConfiguration(); | |||
m_dispatcher = new btCollisionDispatcher(m_collision_configuration); | |||
// The actual physics solver | |||
m_solver = new btSequentialImpulseConstraintSolver; | |||
// The world. | |||
m_dynamics_world = new btDiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collision_configuration); | |||
} | |||
virtual void tick_game(float seconds) | |||
{ | |||
entity::tick_game(seconds); | |||
//step the simulation | |||
if (m_dynamics_world) | |||
{ | |||
//the "+1" is to have at least one Timestep and to ensure float to int .5f conversion. | |||
int steps = (int)(seconds / m_timestep) + 1; | |||
m_dynamics_world->stepSimulation(seconds, steps, m_timestep); | |||
} | |||
} | |||
//Rip-Off of the btKinematicClosestNotMeRayResultCallback | |||
class ClosestNotMeRayResultCallback : public btCollisionWorld::ClosestRayResultCallback | |||
{ | |||
public: | |||
ClosestNotMeRayResultCallback(btCollisionObject* Me, const btVector3& rayFromWorld, const btVector3& rayToWorld) : | |||
btCollisionWorld::ClosestRayResultCallback(rayFromWorld, rayToWorld) | |||
{ | |||
m_me = Me; | |||
} | |||
virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace) | |||
{ | |||
if (rayResult.m_collisionObject == m_me) | |||
return 1.0; | |||
return ClosestRayResultCallback::addSingleResult(rayResult, normalInWorldSpace); | |||
} | |||
protected: | |||
btCollisionObject* m_me; | |||
}; | |||
//Will stop at the first hit. Hit data are supposed to be irrelevant | |||
class AnyHitRayResultCallback : public btCollisionWorld::ClosestRayResultCallback | |||
{ | |||
public: | |||
AnyHitRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld) : | |||
btCollisionWorld::ClosestRayResultCallback(rayFromWorld, rayToWorld) | |||
{ | |||
} | |||
virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace) | |||
{ | |||
UNUSED(rayResult); | |||
UNUSED(normalInWorldSpace); | |||
return .0f; | |||
} | |||
}; | |||
//Returns true when hitting something. If SourceCaster is set, it will be ignored by Raycast. | |||
bool RayHits(RayCastResult& HitResult, eRaycastType RaycastType, const vec3& RayFrom, const vec3& RayTo, EasyPhysic* SourceCaster = nullptr) | |||
{ | |||
bool bResult = false; | |||
btCollisionWorld::RayResultCallback* BtRayResult = nullptr; | |||
btCollisionWorld::ClosestRayResultCallback* BtRayResult_Closest; | |||
btCollisionWorld::AllHitsRayResultCallback* BtRayResult_AllHits; | |||
switch (RaycastType) | |||
{ | |||
case ERT_Closest: | |||
{ | |||
if (SourceCaster) | |||
BtRayResult_Closest = new ClosestNotMeRayResultCallback(SourceCaster->m_collision_object, LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo)); | |||
else | |||
BtRayResult_Closest = new btCollisionWorld::ClosestRayResultCallback(LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo)); | |||
BtRayResult = BtRayResult_Closest; | |||
break; | |||
} | |||
case ERT_AllHit: | |||
{ | |||
BtRayResult_AllHits = new btCollisionWorld::AllHitsRayResultCallback(LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo)); | |||
BtRayResult = BtRayResult_AllHits; | |||
break; | |||
} | |||
case ERT_AnyHit: | |||
{ | |||
BtRayResult_Closest = new AnyHitRayResultCallback(LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo)); | |||
BtRayResult = BtRayResult_Closest; | |||
break; | |||
} | |||
default: | |||
{ | |||
ASSERT(0, "Raycast not handled"); | |||
} | |||
} | |||
m_dynamics_world->rayTest(LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo), *BtRayResult); | |||
if (BtRayResult->hasHit()) | |||
{ | |||
bResult = true; | |||
switch (RaycastType) | |||
{ | |||
case ERT_Closest: | |||
{ | |||
HitResult.m_collider_list << (EasyPhysic*)BtRayResult_Closest->m_collisionObject->getUserPointer(); | |||
HitResult.m_hit_normal_list << BT2LOLU_VEC3(BtRayResult_Closest->m_hitNormalWorld); | |||
HitResult.m_hit_point_list << BT2LOLU_VEC3(BtRayResult_Closest->m_hitPointWorld); | |||
HitResult.m_hit_fraction_list << BtRayResult_Closest->m_closestHitFraction; | |||
break; | |||
} | |||
case ERT_AllHit: | |||
{ | |||
for (int i = 0; i < BtRayResult_AllHits->m_collisionObjects.size(); i++) | |||
{ | |||
HitResult.m_collider_list << (EasyPhysic*)BtRayResult_AllHits->m_collisionObjects[i]->getUserPointer(); | |||
HitResult.m_hit_normal_list << BT2LOLU_VEC3(BtRayResult_AllHits->m_hitNormalWorld[i]); | |||
HitResult.m_hit_point_list << BT2LOLU_VEC3(BtRayResult_AllHits->m_hitPointWorld[i]); | |||
HitResult.m_hit_fraction_list << BtRayResult_AllHits->m_hitFractions[i]; | |||
} | |||
break; | |||
} | |||
default: | |||
{ | |||
ASSERT(0, "Raycast not handled"); | |||
} | |||
} | |||
} | |||
delete BtRayResult; | |||
return bResult; | |||
} | |||
void Exit() | |||
{ | |||
delete m_dynamics_world; | |||
delete m_solver; | |||
delete m_dispatcher; | |||
delete m_collision_configuration; | |||
delete m_broadphase; | |||
} | |||
btDiscreteDynamicsWorld* GetWorld() | |||
{ | |||
return m_dynamics_world; | |||
} | |||
private: | |||
void CustomSetContinuousDetection(bool ShouldUseCCD) | |||
{ | |||
if (m_dynamics_world) | |||
m_dynamics_world->getDispatchInfo().m_useContinuous = ShouldUseCCD; | |||
} | |||
void CustomSetGravity(vec3 &NewGravity) | |||
{ | |||
if (m_dynamics_world) | |||
m_dynamics_world->setGravity(LOL2BT_VEC3(NewGravity * LOL2BT_UNIT)); | |||
} | |||
void CustomSetWorldLimit(vec3 const &NewWorldMin, vec3 const &NewWorldMax) | |||
{ | |||
UNUSED(NewWorldMin); | |||
UNUSED(NewWorldMax); | |||
} | |||
void CustomSetTimestep(float NewTimestep) { } | |||
//broadphase | |||
btBroadphaseInterface* m_broadphase; | |||
btAxisSweep3* m_Sweep_broadphase; | |||
// Set up the collision configuration and dispatc | |||
btDefaultCollisionConfiguration* m_collision_configuration; | |||
btCollisionDispatcher* m_dispatcher; | |||
// The actual physics solver | |||
btSequentialImpulseConstraintSolver* m_solver; | |||
// The world. | |||
btDiscreteDynamicsWorld* m_dynamics_world; | |||
public: | |||
//Main logic : | |||
//The Set*() functions do the all-lib-independent data storage. | |||
//And then it calls the CustomSet*() which are the specialized versions. | |||
//Sets the continuous collision detection flag. | |||
void SetContinuousDetection(bool ShouldUseCCD) | |||
{ | |||
m_using_CCD = ShouldUseCCD; | |||
CustomSetContinuousDetection(ShouldUseCCD); | |||
} | |||
//Sets the simulation gravity. | |||
void SetGravity(vec3 &NewGravity) | |||
{ | |||
m_gravity = NewGravity; | |||
CustomSetGravity(NewGravity); | |||
} | |||
//Sets the simulation gravity. | |||
void SetWorldLimit(vec3 const &NewWorldMin, vec3 const &NewWorldMax) | |||
{ | |||
m_world_min = NewWorldMin; | |||
m_world_max = NewWorldMax; | |||
CustomSetWorldLimit(NewWorldMin, NewWorldMax); | |||
} | |||
//Sets the simulation fixed timestep. | |||
void SetTimestep(float NewTimestep) | |||
{ | |||
if (NewTimestep > .0f) | |||
{ | |||
m_timestep = NewTimestep; | |||
CustomSetTimestep(NewTimestep); | |||
} | |||
} | |||
private: | |||
friend class EasyPhysic; | |||
friend class EasyCharacterController; | |||
friend class EasyConstraint; | |||
enum eEasyPhysicType | |||
{ | |||
EEPT_Dynamic, | |||
EEPT_Static, | |||
EEPT_Ghost, | |||
EEPT_CollisionObject, | |||
EEPT_CharacterController, | |||
EEPT_MAX | |||
}; | |||
//m_owner_simulation | |||
//Adds the given EasyPhysic to the correct list. | |||
void ObjectRegistration(bool AddObject, EasyPhysic* NewEP, eEasyPhysicType CurType) | |||
{ | |||
array<EasyPhysic*>* SearchList = nullptr; | |||
switch(CurType) | |||
{ | |||
case EEPT_Dynamic: | |||
{ | |||
SearchList = &m_dynamic_list; | |||
break; | |||
} | |||
case EEPT_Static: | |||
{ | |||
SearchList = &m_static_list; | |||
break; | |||
} | |||
case EEPT_Ghost: | |||
{ | |||
SearchList = &m_ghost_list; | |||
break; | |||
} | |||
case EEPT_CollisionObject: | |||
{ | |||
SearchList = &m_collision_object_list; | |||
break; | |||
} | |||
case EEPT_CharacterController: | |||
{ | |||
SearchList = &m_character_controller_list; | |||
break; | |||
} | |||
default: | |||
{ | |||
ASSERT(0, "Physic type does not exist."); | |||
} | |||
} | |||
if (AddObject) | |||
{ | |||
NewEP->m_owner_simulation = this; | |||
(*SearchList) << NewEP; | |||
} | |||
else | |||
{ | |||
NewEP->m_owner_simulation = nullptr; | |||
SearchList->remove_item(NewEP); | |||
} | |||
} | |||
void ObjectRegistration(bool AddObject, EasyConstraint* NewEC) | |||
{ | |||
array<EasyConstraint*>* SearchList = nullptr; | |||
SearchList = &m_constraint_list; | |||
if (AddObject) | |||
{ | |||
NewEC->m_owner_simulation = this; | |||
(*SearchList) << NewEC; | |||
} | |||
else | |||
{ | |||
NewEC->m_owner_simulation = nullptr; | |||
SearchList->remove_item(NewEC); | |||
} | |||
} | |||
//Easy Physics body List | |||
array<EasyPhysic*> m_dynamic_list; | |||
array<EasyPhysic*> m_static_list; | |||
array<EasyPhysic*> m_ghost_list; | |||
array<EasyPhysic*> m_collision_object_list; | |||
array<EasyPhysic*> m_character_controller_list; | |||
array<EasyConstraint*> m_constraint_list; | |||
//Easy Physics data storage | |||
float m_timestep; | |||
bool m_using_CCD; | |||
vec3 m_gravity; | |||
vec3 m_world_min; | |||
vec3 m_world_max; | |||
}; | |||
} /* namespace phys */ | |||
} /* namespace lol */ | |||
@@ -1,11 +0,0 @@ | |||
include $(top_srcdir)/build/autotools/common.am | |||
if BUILD_SAMPLES | |||
bin_PROGRAMS = sample | |||
endif | |||
sample_SOURCES = sample.cpp | |||
sample_CPPFLAGS = $(AM_CPPFLAGS) | |||
sample_DEPENDENCIES = @LOL_DEPS@ | |||
@@ -1,44 +0,0 @@ | |||
// | |||
// Lol Engine — Sandbox program | |||
// | |||
// Copyright © 2005—2018 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// This program is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <lol/engine.h> | |||
using namespace lol; | |||
int main(int, char **) | |||
{ | |||
timer t; | |||
bigint<128> x(17), y(23); | |||
x.print(); | |||
y.print(); | |||
auto z = x * y; | |||
z.print(); | |||
for (int i = 0; i < 500000; ++i) | |||
{ | |||
x = (bigint<128>)(x * x); | |||
x ^= y; | |||
} | |||
printf("%d %d\n", (int)x, (int)y); | |||
printf("Time: %f s\n", t.get()); | |||
return EXIT_SUCCESS; | |||
} | |||
@@ -1,147 +0,0 @@ | |||
// | |||
// Lol Engine — Simplex Noise tutorial | |||
// | |||
// Copyright © 2010—2017 Sam Hocevar <sam@hocevar.net> | |||
// © 2013-2014 Guillaume Bittoun <guillaume.bittoun@gmail.com> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <lol/engine.h> | |||
using namespace lol; | |||
/* Constants to tweak */ | |||
ivec2 const size(1280 * 1, 720 * 1); | |||
float const zoom = 0.03f / 1; | |||
int const octaves = 1; | |||
int main(int argc, char **argv) | |||
{ | |||
UNUSED(argc, argv); | |||
srand(time(nullptr)); | |||
/* Create an image */ | |||
image img(size); | |||
array2d<vec4> &data = img.lock2d<PixelFormat::RGBA_F32>(); | |||
/* Declare plenty of allocators */ | |||
simplex_noise<2> s2; | |||
simplex_noise<3> s3; | |||
simplex_noise<4> s4; | |||
simplex_noise<5> s5; | |||
simplex_noise<6> s6; | |||
simplex_noise<7> s7; | |||
simplex_noise<8> s8; | |||
simplex_noise<9> s9; | |||
simplex_noise<10> s10; | |||
simplex_noise<11> s11; | |||
simplex_noise<12> s12; | |||
/* Fill image with simplex noise */ | |||
for (int j = 0; j < size.y; ++j) | |||
for (int i = 0; i < size.x; ++i) | |||
{ | |||
int cell = j / (size.y / 2) * 3 + i / (size.x / 3); | |||
float x = (float)i, y = (float)j; | |||
float sum = 0.f, coeff = 0.f; | |||
int const max_k = 1 << octaves; | |||
bool b_centre = false, b_sphere1 = false, b_sphere2 = false; | |||
for (int k = 1; k < max_k; k *= 2) | |||
{ | |||
float t = 0.f; | |||
switch (cell) | |||
{ | |||
case 0: | |||
t = s2.eval(zoom * k * vec2(x, y)); | |||
break; | |||
case 1: | |||
t = s3.eval(zoom * k * vec3(x, 1.f, y)); | |||
break; | |||
case 2: | |||
t = s4.eval(zoom * k * vec4(x, 1.f, y, 2.f)); | |||
break; | |||
case 3: | |||
t = s6.eval(zoom * k * vec6(x, 1.f, 2.f, y, 3.f, 4.f)); | |||
break; | |||
case 4: | |||
t = s8.eval(zoom * k * vec8(x, 1.f, 2.f, 3.f, | |||
y, 4.f, 5.f, 6.f)); | |||
break; | |||
case 5: | |||
//t = s12.eval(zoom * k * vec12(x / 2, -x / 2, y / 2, -y / 2, | |||
// -x / 2, x / 2, -y / 2, y / 2, | |||
// 7.f, 8.f, 9.f, 10.f)); | |||
t = s12.eval(zoom * k * vec12(x, 1.f, 2.f, 3.f, 4.f, 5.f, | |||
y, 6.f, 7.f, 8.f, 9.f, 10.f)); | |||
break; | |||
default: | |||
break; | |||
} | |||
if (t == -2.f) b_centre = true; | |||
if (t == -3.f) b_sphere1 = true; | |||
if (t == -4.f) b_sphere2 = true; | |||
sum += 1.f / k * t; | |||
coeff += 1.f / k; | |||
} | |||
if (b_centre) | |||
data[i][j] = vec4(1.f, 0.f, 1.f, 1.f); | |||
else if (b_sphere1) | |||
data[i][j] = vec4(0.f, 1.f, 0.f, 1.f); | |||
else if (b_sphere2) | |||
data[i][j] = vec4(0.f, 0.f, 1.f, 1.f); | |||
else | |||
{ | |||
float c = saturate(0.5f + 0.5f * sum / coeff); | |||
data[i][j] = vec4(c, c, c, 1.f); | |||
//data[i][j] = Color::HSVToRGB(vec4(c, 1.0f, 0.5f, 1.f)); | |||
} | |||
} | |||
#if 0 | |||
/* Mark simplex vertices */ | |||
vec2 diagonal = normalize(vec2(1.f)); | |||
vec2 dx = mat2::rotate(radians(60.f)) * diagonal; | |||
vec2 dy = mat2::rotate(radians(-60.f)) * diagonal; | |||
for (int j = -100; j < 100; ++j) | |||
for (int i = -100; i < 100; ++i) | |||
{ | |||
auto putpixel = [&](ivec2 p, vec4 c = vec4(1.f, 0.f, 1.f, 1.f)) | |||
{ | |||
if (p.x >= 0 && p.x < size.x - 1 && p.y >= 0 && p.y < size.y - 1) | |||
data[p.x][p.y] = c; | |||
}; | |||
ivec2 coord = ivec2(i / zoom * dx + j / zoom * dy); | |||
vec2 g = s2.gradient((i + 0.1f) * dx + (j + 0.1f) * dy); | |||
for (int t = 0; t < 40; ++t) | |||
putpixel(coord + (ivec2)(g * (t / 2.f)), vec4(0.f, 1.f, 0.f, 1.f)); | |||
putpixel(coord); | |||
putpixel(coord + ivec2(1, 0)); | |||
putpixel(coord + ivec2(0, 1)); | |||
putpixel(coord + ivec2(1, 1)); | |||
} | |||
#endif | |||
/* Save image */ | |||
img.unlock2d(data); | |||
img.save("simplex.png"); | |||
} | |||
@@ -1,46 +0,0 @@ | |||
<lolbot> en france tfacon :) | |||
% | |||
<lolbot> Je crois qu'il est en AMerique mon ptit gars, je me lève tôt demain matin, je pars bosser | |||
% | |||
<lolbot> c'est ou ? | |||
% | |||
<lolbot> Touky bloque avec Guillaume devant des questions d'hygiène | |||
% | |||
<lolbot> oui c'est le kiff les nouveaux locaux omg | |||
% | |||
<lolbot> CPU à priori mon vc6.0 est dans le port, dans l'eau, probablement completement bourre, car les bars sont pas trompés http://files.sharenator.com/Kill_it_With_Fire_Aliens-s576x304-132453.jpg | |||
% | |||
<lolbot> j'ai recommencé le jeu est proche de FTL au final | |||
% | |||
<lolbot> au fait tu peux devenir chef-Producer, ils en sont capables de nous parler de l'hégémonie du grand gourou du groupe O+ et me l'étaler sur le site reçoit un prix acceptable | |||
% | |||
<rez_> ha ben | |||
<rez_> ça va vite le net chez nous | |||
<rez_> je récupère un torrent de 3Go à 12 Mo par secondes | |||
<lolbot> c'est franchement pas grave je passe plus de 100 lolipop par secondes | |||
% | |||
<lolbot> Touky: (et faut attendre tout le middleware pendant ma pause de midi comme vous genre On aura saisi qu'il est pas censé être déja le HA. GAYYYYYY c'est mort | |||
% | |||
<sam> bon c'est rigolo mais ça va super nous gaver | |||
<lolbot> ouais mais ça fait des frissons tout partout | |||
% | |||
<Jnat1> cocaine + lolbot = shitloads of fun | |||
<lolbot> ouais avec theory of fun bien proéminent | |||
% | |||
<lolbot> RuTT: p'tain mais Gameblog, ce Gorafi du JV | |||
% | |||
<lolbot> wanadoo hahahaah la loooooooooooooooooooooooooooooooooooozzzeeee | |||
% | |||
<lolbot> rez_: nan les pédophiles abiment la marchandise | |||
% | |||
<lolbot> rez_: et ça sentait la prèz bidonnée, de tellement loin… et ces ptits pédés : ils se sont succédées | |||
% | |||
<lolbot> c'est .... hum .... "normal" ? | |||
% | |||
<lolbot> rez_: mais bon, suffit de mettre leur caca chez nous | |||
% | |||
<lolbot> rez_: c'est a eux alors qu'on est pas loin de chez toi de remplir les champs de vecteurs, comme dans diablo 3 en built-in, mais des bougnoules marrants | |||
% | |||
<lolbot> TypX: aucun signe de vie ridicule par rapport à la cuisine !! | |||
% | |||
<lolbot> voir ENCULER de rire |
@@ -1,88 +0,0 @@ | |||
// | |||
// Lol Engine — Triangle tutorial | |||
// | |||
// Copyright © 2012—2019 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <memory> | |||
#include <lol/engine.h> | |||
#include "loldebug.h" | |||
using namespace lol; | |||
LOLFX_RESOURCE_DECLARE(01_triangle); | |||
class Triangle : public WorldEntity | |||
{ | |||
public: | |||
virtual bool init_draw() override | |||
{ | |||
array<vec2> vertices | |||
{ | |||
vec2( 0.0f, 0.8f), | |||
vec2(-0.8f, -0.8f), | |||
vec2( 0.8f, -0.8f), | |||
}; | |||
m_shader = Shader::Create(LOLFX_RESOURCE_NAME(01_triangle)); | |||
m_coord = m_shader->GetAttribLocation(VertexUsage::Position, 0); | |||
m_vdecl = std::make_shared<VertexDeclaration>(VertexStream<vec2>(VertexUsage::Position)); | |||
m_vbo = std::make_shared<VertexBuffer>(vertices.bytes()); | |||
m_vbo->set_data(vertices.data(), vertices.bytes()); | |||
return true; | |||
} | |||
virtual void tick_draw(float seconds, Scene &scene) override | |||
{ | |||
WorldEntity::tick_draw(seconds, scene); | |||
m_shader->Bind(); | |||
m_vdecl->Bind(); | |||
m_vdecl->SetStream(m_vbo, m_coord); | |||
m_vdecl->DrawElements(MeshPrimitive::Triangles, 0, 3); | |||
m_vdecl->Unbind(); | |||
} | |||
virtual bool release_draw() override | |||
{ | |||
m_shader.reset(); | |||
m_vdecl.reset(); | |||
m_vbo.reset(); | |||
return true; | |||
} | |||
private: | |||
std::shared_ptr<Shader> m_shader; | |||
ShaderAttrib m_coord; | |||
std::shared_ptr<VertexDeclaration> m_vdecl; | |||
std::shared_ptr<VertexBuffer> m_vbo; | |||
}; | |||
int main(int argc, char **argv) | |||
{ | |||
sys::init(argc, argv); | |||
Application app("Tutorial 1: Triangle", ivec2(640, 480), 60.0f); | |||
new DebugFps(5, 5); | |||
new Triangle(); | |||
app.Run(); | |||
return EXIT_SUCCESS; | |||
} | |||
@@ -1,35 +0,0 @@ | |||
/* | |||
* Awesome triangle shader | |||
*/ | |||
technique FlatColor | |||
{ | |||
pass DefaultPass | |||
{ | |||
vertexshader = vert; | |||
pixelshader = frag; | |||
} | |||
} | |||
[vert.glsl] | |||
#version 130 | |||
in vec2 in_position; | |||
void main(void) | |||
{ | |||
gl_Position = vec4(in_position, 0.0, 1.0); | |||
} | |||
[frag.glsl] | |||
#version 130 | |||
#if defined GL_ES | |||
precision highp float; | |||
#endif | |||
void main(void) | |||
{ | |||
gl_FragColor = vec4(0.7, 0.2, 0.5, 1.0); | |||
} | |||
@@ -1,69 +0,0 @@ | |||
<?xml version="1.0" encoding="utf-8"?> | |||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | |||
<PropertyGroup Label="LolMacros"> | |||
<LolDir Condition="Exists('$(SolutionDir)\lol')">$(SolutionDir)\lol</LolDir> | |||
<LolDir Condition="!Exists('$(SolutionDir)\lol')">$(SolutionDir)</LolDir> | |||
</PropertyGroup> | |||
<ItemGroup Label="ProjectConfigurations"> | |||
<ProjectConfiguration Include="Debug|NX64"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>NX64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|ORBIS"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>ORBIS</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|Win32"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>Win32</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Debug|x64"> | |||
<Configuration>Debug</Configuration> | |||
<Platform>x64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|NX64"> | |||
<Configuration>Release</Configuration> | |||
<Platform>NX64</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|ORBIS"> | |||
<Configuration>Release</Configuration> | |||
<Platform>ORBIS</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|Win32"> | |||
<Configuration>Release</Configuration> | |||
<Platform>Win32</Platform> | |||
</ProjectConfiguration> | |||
<ProjectConfiguration Include="Release|x64"> | |||
<Configuration>Release</Configuration> | |||
<Platform>x64</Platform> | |||
</ProjectConfiguration> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<ClCompile Include="01_triangle.cpp" /> | |||
</ItemGroup> | |||
<ItemGroup> | |||
<LolFxCompile Include="01_triangle.lolfx" /> | |||
</ItemGroup> | |||
<Import Project="$(LolDir)\build\msbuild\lol-core.props" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol-bullet.props" /> | |||
<PropertyGroup Label="Globals"> | |||
<ProjectGuid>{b92abadc-45be-4cc5-b724-9426053123a1}</ProjectGuid> | |||
<ConfigurationType>Application</ConfigurationType> | |||
<Keyword>Win32Proj</Keyword> | |||
</PropertyGroup> | |||
<Import Project="$(LolDir)\build\msbuild\lol.config.props" /> | |||
<ImportGroup Label="ExtensionSettings"> | |||
<Import Project="$(LolDir)\build\msbuild\lolfx.props" /> | |||
</ImportGroup> | |||
<ImportGroup Label="PropertySheets"> | |||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol.vars.props" /> | |||
</ImportGroup> | |||
<PropertyGroup Label="UserMacros" /> | |||
<Import Project="$(LolDir)\build\msbuild\lol.rules.props" /> | |||
<ItemDefinitionGroup /> | |||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> | |||
<ImportGroup Label="ExtensionTargets"> | |||
<Import Project="$(LolDir)\build\msbuild\lolfx.targets" /> | |||
</ImportGroup> | |||
</Project> |
@@ -1,190 +0,0 @@ | |||
// | |||
// Lol Engine — Cube tutorial | |||
// | |||
// Copyright © 2011—2019 Sam Hocevar <sam@hocevar.net> | |||
// | |||
// Lol Engine is free software. It comes without any warranty, to | |||
// the extent permitted by applicable law. You can redistribute it | |||
// and/or modify it under the terms of the Do What the Fuck You Want | |||
// to Public License, Version 2, as published by the WTFPL Task Force. | |||
// See http://www.wtfpl.net/ for more details. | |||
// | |||
#if HAVE_CONFIG_H | |||
# include "config.h" | |||
#endif | |||
#include <lol/engine.h> | |||
#include "loldebug.h" | |||
using namespace lol; | |||
LOLFX_RESOURCE_DECLARE(02_cube); | |||
class Cube : public WorldEntity | |||
{ | |||
public: | |||
Cube() | |||
{ | |||
m_camera = new Camera(); | |||
m_camera->SetProjection(mat4::perspective(radians(30.f), 640.f, 480.f, .1f, 1000.f)); | |||
m_camera->SetView(mat4::lookat(vec3(-15.f, 5.f, 0.f), | |||
vec3(0.f, -1.f, 0.f), | |||
vec3(0.f, 1.f, 0.f))); | |||
Scene& scene = Scene::GetScene(); | |||
scene.PushCamera(m_camera); | |||
Ticker::Ref(m_camera); | |||
} | |||
~Cube() | |||
{ | |||
Scene& scene = Scene::GetScene(); | |||
scene.PopCamera(m_camera); | |||
Ticker::Unref(m_camera); | |||
} | |||
virtual bool init_draw() override | |||
{ | |||
array<vec3, vec3> mesh | |||
{ | |||
// Front vertices/colors | |||
{ vec3(-1.0, -1.0, 1.0), vec3(1.0, 0.0, 1.0) }, | |||
{ vec3( 1.0, -1.0, 1.0), vec3(0.0, 1.0, 0.0) }, | |||
{ vec3( 1.0, 1.0, 1.0), vec3(1.0, 0.5, 0.0) }, | |||
{ vec3(-1.0, 1.0, 1.0), vec3(1.0, 1.0, 0.0) }, | |||
// Back | |||
{ vec3(-1.0, -1.0, -1.0), vec3(1.0, 0.0, 0.0) }, | |||
{ vec3( 1.0, -1.0, -1.0), vec3(0.0, 0.5, 0.0) }, | |||
{ vec3( 1.0, 1.0, -1.0), vec3(0.0, 0.5, 1.0) }, | |||
{ vec3(-1.0, 1.0, -1.0), vec3(0.0, 0.0, 1.0) }, | |||
}; | |||
array<uint16_t> lines_indices | |||
{ | |||
0, 1, 1, 2, 2, 3, 3, 0, | |||
4, 5, 5, 6, 6, 7, 7, 4, | |||
0, 4, 1, 5, 2, 6, 3, 7, | |||
}; | |||
array<uint16_t> faces_indices | |||
{ | |||
0, 1, 2, 2, 3, 0, 1, 5, 6, 6, 2, 1, | |||
7, 6, 5, 5, 4, 7, 4, 0, 3, 3, 7, 4, | |||
4, 5, 1, 1, 0, 4, 3, 2, 6, 6, 7, 3, | |||
}; | |||
m_shader = Shader::Create(LOLFX_RESOURCE_NAME(02_cube)); | |||
m_mvp = m_shader->GetUniformLocation("u_matrix"); | |||
m_coord = m_shader->GetAttribLocation(VertexUsage::Position, 0); | |||
m_color = m_shader->GetAttribLocation(VertexUsage::Color, 0); | |||
m_vdecl = std::make_shared<VertexDeclaration>( | |||
VertexStream<vec3,vec3>(VertexUsage::Position, | |||
VertexUsage::Color)); | |||
m_vbo = std::make_shared<VertexBuffer>(mesh.bytes()); | |||
m_vbo->set_data(mesh.data(), mesh.bytes()); | |||
m_lines_ibo = std::make_shared<IndexBuffer>(lines_indices.bytes()); | |||
m_lines_ibo->set_data(lines_indices.data(), lines_indices.bytes()); | |||
m_faces_ibo = std::make_shared<IndexBuffer>(faces_indices.bytes()); | |||
m_faces_ibo->set_data(faces_indices.data(), faces_indices.bytes()); | |||
return true; | |||
} | |||
virtual void tick_game(float seconds) override | |||
{ | |||
WorldEntity::tick_game(seconds); | |||
m_angle += seconds * radians(45.0f); | |||
mat4 anim = mat4::rotate(m_angle, vec3(0, 1, 0)); | |||
mat4 model = mat4::translate(vec3(0, 0, -4.5)); | |||
mat4 view = mat4::lookat(vec3(0, 2, 0), vec3(0, 0, -4), vec3(0, 1, 0)); | |||
mat4 proj = mat4::perspective(radians(45.0f), 640.0f, 480.0f, 0.1f, 10.0f); | |||
m_matrix = proj * view * model * anim; | |||
{ | |||
auto context0 = Debug::DrawContext::New(Color::red); | |||
{ | |||
auto context1 = Debug::DrawContext::New(Color::blue); | |||
Debug::DrawBox(box3(vec3(0.f), vec3(1.2f))); | |||
Debug::DrawGrid(vec3(0.f), vec3::axis_x, vec3::axis_y, vec3::axis_z, 10.0f); | |||
{ | |||
auto context2 = Debug::DrawContext::New(context0); | |||
Debug::DrawBox(box3(vec3(0.f), vec3(1.3f))); | |||
} | |||
{ | |||
auto context2 = Debug::DrawContext::New(context0); | |||
context2.SetColor(Color::yellow); | |||
Debug::DrawBox(box3(vec3(-1.f), vec3(1.4f))); | |||
} | |||
} | |||
Debug::DrawBox(box3(vec3(0.f), vec3(1.1f))); | |||
} | |||
} | |||
virtual void tick_draw(float seconds, Scene &scene) override | |||
{ | |||
WorldEntity::tick_draw(seconds, scene); | |||
scene.get_renderer()->clear_color(vec4(0.0f, 0.0f, 0.0f, 1.0f)); | |||
m_shader->Bind(); | |||
m_vdecl->Bind(); | |||
m_vdecl->SetStream(m_vbo, m_coord, m_color); | |||
m_shader->SetUniform(m_mvp, m_matrix); | |||
m_lines_ibo->Bind(); | |||
m_vdecl->DrawIndexedElements(MeshPrimitive::Lines, m_lines_ibo->size() / sizeof(uint16_t)); | |||
m_lines_ibo->Unbind(); | |||
m_shader->SetUniform(m_mvp, m_matrix * mat4::scale(0.5f)); | |||
m_faces_ibo->Bind(); | |||
m_vdecl->DrawIndexedElements(MeshPrimitive::Triangles, m_faces_ibo->size() / sizeof(uint16_t)); | |||
m_faces_ibo->Unbind(); | |||
m_vdecl->Unbind(); | |||
} | |||
virtual bool release_draw() override | |||
{ | |||
m_shader.reset(); | |||
m_vdecl.reset(); | |||
m_vbo.reset(); | |||
m_lines_ibo.reset(); | |||
m_faces_ibo.reset(); | |||
return true; | |||
} | |||
private: | |||
Camera* m_camera = nullptr; | |||
float m_angle = 0.0f; | |||
mat4 m_matrix; | |||
std::shared_ptr<Shader> m_shader; | |||
ShaderAttrib m_coord, m_color; | |||
ShaderUniform m_mvp; | |||
std::shared_ptr<VertexDeclaration> m_vdecl; | |||
std::shared_ptr<VertexBuffer> m_vbo; | |||
std::shared_ptr<IndexBuffer> m_lines_ibo, m_faces_ibo; | |||
}; | |||
int main(int argc, char **argv) | |||
{ | |||
sys::init(argc, argv); | |||
Application app("Tutorial 2: Cube", ivec2(640, 480), 60.0f); | |||
new DebugFps(5, 5); | |||
new Cube(); | |||
app.Run(); | |||
return EXIT_SUCCESS; | |||
} | |||
@@ -1,32 +0,0 @@ | |||
[vert.glsl] | |||
#version 130 | |||
attribute vec3 in_position; | |||
attribute vec3 in_color; | |||
uniform mat4 u_matrix; | |||
out vec3 pass_color; | |||
void main(void) | |||
{ | |||
gl_Position = u_matrix * vec4(in_position, 1.0); | |||
pass_color = in_color; | |||
} | |||
[frag.glsl] | |||
#version 130 | |||
#if defined GL_ES | |||
precision highp float; | |||
#endif | |||
in vec3 pass_color; | |||
void main(void) | |||
{ | |||
gl_FragColor = vec4(pass_color, 1.0); | |||
} | |||