Merge branch 'master' into mirceakitsune/world_cubemaps
authorMirceaKitsune <sonichedgehog_hyperblast00@yahoo.com>
Thu, 5 Apr 2012 15:53:00 +0000 (18:53 +0300)
committerMirceaKitsune <sonichedgehog_hyperblast00@yahoo.com>
Thu, 5 Apr 2012 15:53:00 +0000 (18:53 +0300)
scripts/Makefile [new file with mode: 0644]
scripts/shader-audit.sh
scripts/shader-cpp.sh [new file with mode: 0755]
scripts/shader-parser.subr [new file with mode: 0644]
scripts/shaderlist.txt

diff --git a/scripts/Makefile b/scripts/Makefile
new file mode 100644 (file)
index 0000000..a4bfcef
--- /dev/null
@@ -0,0 +1,13 @@
+INFILES = $(wildcard *.shader.in)
+GENERATEDFILES = $(patsubst %.shader.in,%.shader,$(INFILES))
+
+all: shaderlist.txt $(GENERATEDFILES)
+
+%.shader: %.shader.in
+       ./shader-cpp.sh "$<" > "$@"
+
+clean:
+       $(RM) "$(GENERATEDFILES)"
+
+shaderlist.txt:
+       ls -1 *.shader | cut -d . -f 1 > "$@"
index 54018b9..c583f0e 100755 (executable)
@@ -6,6 +6,8 @@ case "$0" in
                ;;
 esac
 
+. ./shader-parser.subr
+
 pid=$$
 status=true
 trap 'status=false' USR1
@@ -28,11 +30,6 @@ warn()
 LF="
 "
 
-normalize()
-{
-       echo "$1" | sed 's/\.\(tga\|jpg\|png\)$//'
-}
-
 allowed_prefixes=
 forbidden_prefixes=
 
@@ -281,54 +278,62 @@ use_texture()
 }
 
 parsing_shader=
-parse_shaderstage()
+parse_shaderstage_pre()
 {
        ss_blendfunc=none
        ss_alphafunc=none
        ss_alphagen=none
        ss_map=
-       while read L A1 Aother; do
-               case "`echo "$L" | tr A-Z a-z`" in
-                       blendfunc)
-                               ss_blendfunc=`echo $A1 $Aother | tr A-Z a-z`
-                               ;;
-                       alphafunc)
-                               ss_alphafunc=`echo $A1 | tr A-Z a-z`
-                               ;;
-                       alphagen)
-                               ss_alphagen=`echo $A1 | tr A-Z a-z`
-                               ;;
-                       map|clampmap)
-                               case "$A1" in
-                                       '$lightmap')
-                                               ;;
-                                       *)
-                                               use_texture "$parsing_shader" "`normalize "$A1"`" map
-                                               ss_map="`normalize "$A1"`"
-                                               offsetmapping_match8=firststagedone
-                                               ;;
-                               esac
-                               ;;
-                       animmap)
-                               for X in $Aother; do
-                                       use_texture "$parsing_shader" "`normalize "$X"`" animmap
-                               done
-                               for X in $Aother; do
-                                       ss_map="`normalize "$X"`"
-                                       break
-                               done
-                               ;;
-                       '{')
-                               err "brace nesting error in $parsing_shader"
-                               ;;
-                       '}')
+}
+
+parse_shaderstage_line()
+{
+       L=$1
+       A1=$2
+       Aother=$3
+       case "`echo "$L" | tr A-Z a-z`" in
+               blendfunc)
+                       ss_blendfunc=`echo $A1 $Aother | tr A-Z a-z`
+                       ;;
+               alphafunc)
+                       ss_alphafunc=`echo $A1 | tr A-Z a-z`
+                       ;;
+               alphagen)
+                       ss_alphagen=`echo $A1 | tr A-Z a-z`
+                       ;;
+               map|clampmap)
+                       case "$A1" in
+                               '$lightmap')
+                                       ;;
+                               *)
+                                       use_texture "$parsing_shader" "`shader_normalize "$A1"`" map
+                                       ss_map="`shader_normalize "$A1"`"
+                                       offsetmapping_match8=firststagedone
+                                       ;;
+                       esac
+                       ;;
+               animmap)
+                       for X in $Aother; do
+                               use_texture "$parsing_shader" "`shader_normalize "$X"`" animmap
+                       done
+                       for X in $Aother; do
+                               ss_map="`shader_normalize "$X"`"
                                break
-                               ;;
-                       *)
-                               ;;
-               esac
-       done
+                       done
+                       ;;
+               '{')
+                       err "brace nesting error in $parsing_shader"
+                       ;;
+               '}')
+                       break
+                       ;;
+               *)
+                       ;;
+       esac
+}
 
+parse_shaderstage_post()
+{
        if [ -n "$ss_map" ]; then
                if [ -z "$maintexture" ]; then
                        maintexture=$ss_map
@@ -352,59 +357,62 @@ parse_shaderstage()
        fi
 }
 
-parse_shader()
+parse_shader_pre()
 {
        use_texture "$parsing_shader" "$parsing_shader" shader
        offsetmapping_match8=
        textureblending=false
        maintexture=
        nowarn=false
-       while read L A1 Aother; do
-               case "`echo "$L" | tr A-Z a-z`" in
-                       xon_nowarn)
-                               nowarn=true
-                               ;;
-                       dpoffsetmapping)
-                               set -- $Aother
-                               if [ x"$A1" = x"none" ]; then
-                                       offsetmapping_match8=none
-                               elif [ x"$A1" = x"off" ]; then
-                                       offsetmapping_match8=none
-                               elif [ x"$A1" = x"disabled" ]; then
-                                       offsetmapping_match8=none
-                               elif [ x"$2" = x"match8" ]; then
-                                       offsetmapping_match8=`echo "($3 + 0.5) / 1" | bc`
-                               elif [ x"$2" = x"match16" ]; then
-                                       offsetmapping_match8=`echo "($3 / 257 + 0.5) / 1" | bc`
-                               elif [ x"$2" = x"match" ]; then
-                                       offsetmapping_match8=`echo "($3 * 255 + 0.5) / 1" | bc`
-                               elif [ x"$2" = x"bias" ]; then
-                                       offsetmapping_match8=`echo "((1 - $3) * 255 + 0.5) / 1" | bc`
-                               else
-                                       offsetmapping_match8=default
-                               fi
-                               ;;
-                       qer_editorimage)
-                               use_texture "$parsing_shader" "`normalize "$A1"`" editorimage
-                               ;;
-                       skyparms)
-                               use_texture "$parsing_shader" "${A1}_lf" sky
-                               use_texture "$parsing_shader" "${A1}_rt" sky
-                               use_texture "$parsing_shader" "${A1}_up" sky
-                               use_texture "$parsing_shader" "${A1}_dn" sky
-                               use_texture "$parsing_shader" "${A1}_ft" sky
-                               use_texture "$parsing_shader" "${A1}_bk" sky
-                               ;;
-                       '{')
-                               parse_shaderstage
-                               ;;
-                       '}')
-                               break
-                               ;;
-                       *)
-                               ;;
-               esac
-       done
+}
+
+parse_shader_line()
+{
+       L=$1
+       A1=$2
+       Aother=$3
+       case "`echo "$L" | tr A-Z a-z`" in
+               xon_nowarn)
+                       nowarn=true
+                       ;;
+               dpoffsetmapping)
+                       set -- $Aother
+                       if [ x"$A1" = x"none" ]; then
+                               offsetmapping_match8=none
+                       elif [ x"$A1" = x"off" ]; then
+                               offsetmapping_match8=none
+                       elif [ x"$A1" = x"disabled" ]; then
+                               offsetmapping_match8=none
+                       elif [ x"$2" = x"match8" ]; then
+                               offsetmapping_match8=`echo "($3 + 0.5) / 1" | bc`
+                       elif [ x"$2" = x"match16" ]; then
+                               offsetmapping_match8=`echo "($3 / 257 + 0.5) / 1" | bc`
+                       elif [ x"$2" = x"match" ]; then
+                               offsetmapping_match8=`echo "($3 * 255 + 0.5) / 1" | bc`
+                       elif [ x"$2" = x"bias" ]; then
+                               offsetmapping_match8=`echo "((1 - $3) * 255 + 0.5) / 1" | bc`
+                       else
+                               offsetmapping_match8=default
+                       fi
+                       ;;
+               qer_editorimage)
+                       use_texture "$parsing_shader" "`shader_normalize "$A1"`" editorimage
+                       ;;
+               skyparms)
+                       use_texture "$parsing_shader" "${A1}_lf" sky
+                       use_texture "$parsing_shader" "${A1}_rt" sky
+                       use_texture "$parsing_shader" "${A1}_up" sky
+                       use_texture "$parsing_shader" "${A1}_dn" sky
+                       use_texture "$parsing_shader" "${A1}_ft" sky
+                       use_texture "$parsing_shader" "${A1}_bk" sky
+                       ;;
+               *)
+                       ;;
+       esac
+}
+
+parse_shader_post()
+{
        if [ -n "$AUDIT_ALPHACHANNELS" ] && [ -n "$maintexture" ] && ! $textureblending; then
                getstats "../$maintexture.tga" || getstats "../$maintexture.png" || getstats "../$maintexture.jpg"
                case "$mainblendfunc" in
@@ -448,17 +456,18 @@ parse_shader()
        fi
 }
 
-parse_shaderfile()
+parse_shaderfile_pre()
 {
-       case "$1" in
+       s="${parsing_shaderfile%.shader}"
+       case "$s" in
                ## RULE: map_FOO.shader may define tetxures/map_FOO_* and textures/map_FOO/*
                map_*)
-                       allowed_prefixes="textures/map_`echo "$1" | cut -d _ -f 2`_ textures/map_`echo "$1" | cut -d _ -f 2`/ models/map_`echo "$1" | cut -d _ -f 2`_ models/map_`echo "$1" | cut -d _ -f 2`/"
+                       allowed_prefixes="textures/map_`echo "$s" | cut -d _ -f 2`_ textures/map_`echo "$s" | cut -d _ -f 2`/ models/map_`echo "$s" | cut -d _ -f 2`_ models/map_`echo "$s" | cut -d _ -f 2`/"
                        forbidden_prefixes=
                        ;;
                ## RULE: skies_FOO.shader may define tetxures/skies/FOO and textures/skies/FOO_*
                skies_*)
-                       allowed_prefixes="textures/skies/`echo "$1" | cut -d _ -f 2`: textures/skies/`echo "$1" | cut -d _ -f 2`_"
+                       allowed_prefixes="textures/skies/`echo "$s" | cut -d _ -f 2`: textures/skies/`echo "$s" | cut -d _ -f 2`_"
                        forbidden_prefixes=
                        ;;
                ## RULE: model_*.shader may define models/*
@@ -468,40 +477,15 @@ parse_shaderfile()
                        ;;
                ## RULE: any other FOO.shader may define textures/FOO/*
                *)
-                       allowed_prefixes="textures/$1/"
+                       allowed_prefixes="textures/$s/"
                        forbidden_prefixes="textures/skies/ textures/map_ models/"
                        ;;
        esac
-       while read L; do
-               case "$L" in
-                       */*)
-                               parsing_shader="`normalize "$L"`"
-                               if [ x"$L" != x"$parsing_shader" ]; then
-                                       warn "normalized shader name $L to $parsing_shader"
-                               fi
-                               ;;
-                       '{')
-                               parse_shader
-                               ;;
-                       *)
-                               ;;
-               esac
-       done
 }
 
-strip_comments()
-{
-       sed 's,//.*,,g; s,\r, ,g; s,\t, ,g; s,  *, ,g; s, $,,; s,^ ,,; /^$/ d'
-}
-
-t=`mktemp || echo ".temp"`
-for X in *.shader; do
-       strip_comments < "$X" > "$t"
-       parse_shaderfile "${X%.shader}" < "$t"
-done
-rm -f "$t"
+parse_shaders *.shader
 
-textures_avail=`( cd ..; find textures/ -type f -not -name '*.sh' -not -name '*_norm.*' -not -name '*_glow.*' -not -name '*_gloss.*' -not -name '*_reflect.*' -not -name '*.xcf' -not -name '*.txt' ) | while IFS= read -r T; do normalize "$T"; done | sort -u`
+textures_avail=`( cd ..; find textures/ -type f -not -name '*.sh' -not -name '*_norm.*' -not -name '*_glow.*' -not -name '*_gloss.*' -not -name '*_reflect.*' -not -name '*.xcf' -not -name '*.txt' ) | while IFS= read -r T; do shader_normalize "$T"; done | sort -u`
 textures_used=`echo "${textures_used#$LF}" | sort -u`
 
 echo "$textures_used$LF$textures_used$LF$textures_avail" | sort | uniq -u | while IFS= read -r L; do
diff --git a/scripts/shader-cpp.sh b/scripts/shader-cpp.sh
new file mode 100755 (executable)
index 0000000..4d0d4d8
--- /dev/null
@@ -0,0 +1,182 @@
+#!/bin/sh
+
+case "$0" in
+       */*)
+               cd "${0%/*}"
+               ;;
+esac
+
+. ./shader-parser.subr
+set -e
+
+err()
+{
+       echo >&2 "(EE) $*"
+       exit 1
+}
+
+LF="
+"
+TAB="  "
+
+parse_shader_pre()
+{
+       shadertext=
+       shaderconds=
+}
+parse_conditional()
+{
+       shaderconds="$shaderconds$LF$*"
+}
+parse_shader_line()
+{
+       case "$1" in
+               '#if')
+                       parse_conditional $2 $3
+                       ;;
+       esac
+       shadertext="$shadertext$LF$TAB$*"
+}
+parse_shaderstage_pre()
+{
+       shadertext="$shadertext$LF$TAB{"
+}
+parse_shaderstage_line()
+{
+       case "$1" in
+               '#if')
+                       parse_conditional $2 $3
+                       ;;
+       esac
+       shadertext="$shadertext$LF$TAB$TAB$*"
+}
+parse_shaderstage_post()
+{
+       shadertext="$shadertext$LF$TAB}"
+}
+# note: the conds are what is FALSE, not TRUE
+shaderkill()
+{
+       parseALLtheconds=$conds
+       while :; do
+               case "$parseALLtheconds" in
+                       '')
+                               break
+                               ;;
+                       *$LF*)
+                               thiscond=${parseALLtheconds%%$LF*}
+                               parseALLtheconds=${parseALLtheconds#*$LF}
+                               ;;
+                       *)
+                               thiscond=$parseALLtheconds
+                               parseALLtheconds=
+                               ;;
+               esac
+               [ -n "$thiscond" ] || continue
+               echo "$TAB""dpshaderkillifcvar $thiscond"
+       done
+}
+preprocess()
+{
+       echo "$shadertext" | {
+               condstack=
+               while IFS= read -r L; do
+                       [ -n "$L" ] || continue
+                       set -- $L
+                       k=$1
+                       shift
+                       case "$k" in
+                               '#if')
+                                       case "$LF$conds$LF" in
+                                               *"$LF$*$LF"*)
+                                                       condstack=0$condstack
+                                                       ;;
+                                               *)
+                                                       condstack=1$condstack
+                                                       ;;
+                                       esac
+                                       ;;
+                               '#else')
+                                       if [ -z "$condstack" ]; then
+                                               err "unmatched #else"
+                                       fi
+                                       case "$condstack" in
+                                               0*)
+                                                       condstack=1${condstack#0}
+                                                       ;;
+                                               1*)
+                                                       condstack=0${condstack#1}
+                                                       ;;
+                                       esac
+                                       ;;
+                               '#endif')
+                                       if [ -z "$condstack" ]; then
+                                               err "unmatched #endif"
+                                       fi
+                                       condstack=${condstack#?}
+                                       ;;
+                               *)
+                                       case "$condstack" in
+                                               *0*)
+                                                       ;;
+                                               *)
+                                                       echo "${L% }"
+                                                       ;;
+                                       esac
+                                       ;;
+                       esac
+               done
+               if [ -n "$condstack" ]; then
+                       err "unmatched #if"
+               fi
+       }
+}
+conditionalize()
+{
+       case "$1" in
+               '')
+                       # no conditions
+                       echo "$parsing_shader"
+                       echo "{"
+                       shaderkill
+                       preprocess
+                       echo "}"
+                       return
+                       ;;
+               *$LF*)
+                       # many conditions
+                       firstcond="${1%%$LF*}"
+                       restcond="${1#*$LF}"
+                       ;;
+               *)
+                       firstcond=$1
+                       restcond=
+                       ;;
+       esac
+       (
+               conds="$conds$LF$firstcond"
+               conditionalize "$restcond"
+       )
+       (
+               set -- $firstcond
+               case "$2" in
+                       '==') op='!=' ;;
+                       '!=') op='==' ;;
+                       '>') op='<=' ;;
+                       '<') op='>=' ;;
+                       '>=') op='<' ;;
+                       '<=') op='>' ;;
+               esac
+               set -- "$1" "$op" "$3"
+               conds="$conds$LF$*"
+               conditionalize "$restcond"
+       )
+}
+parse_shader_post()
+{
+       allconds=`echo "$shaderconds" | sort -u | grep .`
+       conds=
+       conditionalize "$allconds"
+}
+
+parse_shaders "$@"
diff --git a/scripts/shader-parser.subr b/scripts/shader-parser.subr
new file mode 100644 (file)
index 0000000..ef82832
--- /dev/null
@@ -0,0 +1,122 @@
+#!/bin/sh
+
+# simple shader parsing "framework"
+
+shader_normalize()
+{
+       echo "$1" | sed 's/\.\(tga\|jpg\|png\)$//'
+}
+
+parse_shaderstage_pre()
+{
+       : replace this function after including
+}
+parse_shaderstage_line()
+{
+       : replace this function after including
+}
+parse_shaderstage_post()
+{
+       : replace this function after including
+}
+parse_shaderstage()
+{
+       parse_shaderstage_pre
+       while read shaderparser_L shaderparser_A1 shaderparser_Aother; do
+               case "`echo "$shaderparser_L" | tr A-Z a-z`" in
+                       '{')
+                               err "brace nesting error in $parsing_shader"
+                               ;;
+                       '}')
+                               break
+                               ;;
+                       '')
+                               ;;
+                       *)
+                               parse_shaderstage_line "$shaderparser_L" "$shaderparser_A1" "$shaderparser_Aother"
+                               ;;
+               esac
+       done
+       parse_shaderstage_post
+}
+
+parse_shader_pre()
+{
+       : replace this function after including
+}
+parse_shader_line()
+{
+       : replace this function after including
+}
+parse_shader_post()
+{
+       : replace this function after including
+}
+parse_shader()
+{
+       parse_shader_pre
+       while read shaderparser_L shaderparser_A1 shaderparser_Aother; do
+               case "`echo "$shaderparser_L" | tr A-Z a-z`" in
+                       '{')
+                               parse_shaderstage
+                               ;;
+                       '}')
+                               break
+                               ;;
+                       '')
+                               ;;
+                       *)
+                               parse_shader_line "$shaderparser_L" "$shaderparser_A1" "$shaderparser_Aother"
+                               ;;
+               esac
+       done
+       parse_shader_post
+}
+
+parse_shaderfile_pre()
+{
+       : replace this function after including
+}
+parse_shaderfile_post()
+{
+       : replace this function after including
+}
+parse_shaderfile()
+{
+       parse_shaderfile_pre
+       while read shaderparser_L; do
+               case "$shaderparser_L" in
+                       '{')
+                               parse_shader
+                               ;;
+                       '{')
+                               err "brace nesting error in $parsing_shader"
+                               ;;
+                       '')
+                               ;;
+                       *)
+                               parsing_shader="`shader_normalize "$shaderparser_L"`"
+                               if [ x"$shaderparser_L" != x"$parsing_shader" ]; then
+                                       warn "normalized shader name $shaderparser_L to $parsing_shader"
+                               fi
+                               ;;
+               esac
+       done
+       parse_shaderfile_post
+}
+
+shaderparser_strip_comments()
+{
+       sed 's,//.*,,g; s,\r, ,g; s,\shaderparser_t, ,g; s,  *, ,g; s, $,,; s,^ ,,; /^$/ d'
+}
+
+parse_shaders()
+{
+       shaderparser_t=`mktemp || echo ".temp"`
+       for shaderparser_X in "$@"; do
+               shaderparser_strip_comments < "$shaderparser_X" > "$shaderparser_t"
+               parsing_shaderfile="$shaderparser_X"
+               parse_shaderfile < "$shaderparser_t"
+       done
+       rm -f "$shaderparser_t"
+}
index 24ac2ca..91c8ae4 100644 (file)
@@ -14,31 +14,33 @@ exx
 exx_reflections_off
 facility114invx
 facility114x
-grass
 liquids_lava
 liquids_slime
 liquids_water
 logos
 map_courtfun
+map_darkzone
+map_g-23
 map_glowplant
 map_leave_em_behind
+map_lightspeed
 map_newtonian-nightmare
 map_red-planet
+map_solarium
 map_space-elevator
 map_stormkeep
 map_techassault
 map_xoylent
-map_solarium
 metaltechx
 model_bigfan01
 model_crate02
 model_desertfactory
+model_lightspeed
 model_teleporters
 model_trak
 model_tree
 model_walker-static
 model_xonotic_jumppad01
-model_xoylent
 narmorx
 phillipk1x
 phillipk2x
@@ -58,5 +60,3 @@ trak4x
 trak5x
 trak6x
 trak7x
-
-