Q3MME FX SCRIPTING

Tatooka escribió:Lo que descubrí de los q3mme FX scripts hasta ahora, probando un poco y hablando con Jones y KittenIgnition por IRC:

Aparentemente la sintáxis de los scripts va masomenos así

[GRUPO]/[OBJETO]/[ACCION o EFECTO] {
[...código...]
}

GRUPO es la categoría amplia por así decirlo, ejemplo "weapon" o "player".
OBJETO es el modelo específico, por ejemplo "rocket", "torso", etc.
ACCION o EFECTO es eso, lo que hace ese OBJETO y nosotros queremos modificar visualmente con particles o lights, etc. Por ejemplo "trail", "impact", etc.

Por desgracia no encontré por ningún lado la lista de grupos, objetos o acciones. Las pocas que conozco las fui sacando de scripts.fx que encontré. [hay que hacer una recopilación] Tampoco sé si esos Grupo/Objeto/etc se refieren a models de los PAKs o son entidades declaradas por brugal en el código de WolfcamQL.

Pero sigamos. Dentro de las llaves de ese "bloque" de código van los modificadores al FX. Pueden referirse a Shaders, Sprites, Models, Light sources, Sounds, etc, o a una combinación de varios. Son todos resources que están en los paks o en los sub directorios de WolfcamQL.

Entonces por ejemplo para modificar el trail (estela) de la rocket, abriríamos un bloque así:

weapon/rocket/trail {

}

y dentro declaramos la/s propiedad/es que le queremos asignar a ese efecto específico. Aparentemente no tiene límite (LO QUE DE LA PC, AMEGO).

Dentro de esas propiedades podemos abrir más bloques con más propiedades dentro, por ejemplo un emitter (de partículas), o un interval (de tiempo) y andá a saber qué otros chiches más.

Entonces por ejemplo, para que la estela del rocket vaya tirando chispitas, podemos ponerle algo así:

Código:

weapon/rocket/trail {
   color 1 0.25 0 // color anaranjado
   alpha 0.3 // un poco de transparencia
   shader flareShader // la chispita en sí
   interval 0.001 {
                // un montón de propiedades y modificadores matemáticos para tunear las partículas
      normalize dir v0
      inverse v0
      wobble v0 velocity 150 + rand*10
      scale velocity velocity 175 + rand*50
      emitter 0.1 + rand*0.5 {
         size 2.5 * ( 1 - 0.5 * lerp * 1.5 )
         colorFade 0.1
         moveGravity 1
         Sprite
      }
   }
}

Ayer hablando con KittenIgnition le pregunté el tema del Player Trail (la estela del player model, como se ve en uno de los videos de renkq3), y me dijo que se podía y me tiró un tip.

el grupo/objeto/accion que lo controlan es

Código:

player/torso/trail {
}

Pero para darle un efecto como el que logró renkq3 aparentemente hay que hacer un hack medio bizarro. McCormic sacó una screenshot del model desde el POV de la cámara, lo recortó y lo guardó como Shader. Después lo que hace es ir mostrando la estela con ese Shader y Alpha blending. No me kbió mucho.

En fin... les dejo mi script fx por si quieren ir probando, es el que usé para el fragvideo con MUCHAS modificaciones de prueba, NO APTO para video final. link: http://pastebin.com/K1r1GRCy

Igual estamos viendo de levantar una wiki sobre WolfcamQL para "centralizar" toda la doc del programa en un solo sitio, espero que salga.

Short Guide on FX Scripting
CaNaBiS Version 0.001

The FX system is built around a set of variables and commands to modify them or use them to start an effect. Scripts get started by the engine with certain variables already set and then the script is given control.
Different events have different startup variables set so keep that in mind.

The different variable type that make up the fx system are:

float variable:
Floating point variables that can store a single number

Valid float variable names are:
size, width, angle -> Used by certain commands
t0, t1, t2, t3 -> temporary values you can use for complex calculations

Vectors:
3 floats grouped together under 1 name used for vector math
You can also access specific float by adding 0, 1, 3 to the vector name

origin, velocity, dir, angles: Used by render commands to output stuff
v0, v1, v2, v3 : Temporarary vectors you can use for calculation and storage

So origin0 will behave like a regular float
Using vectors names in math will result in the length of the vector being used

Special variables:
These can only be modified by special commands
color -> red, green, blue, alpha color
shader -> shader used by some commands
model -> model used by some commands



FX Commands:
There's a whole bunch of command to generate effects, modify variables and spawn entities and do vector math

Float math commands:
Using any float variable name a command starts a float math command
examples:
size 5*size -> Size is now 5*original size
angle 360*rand + size -> angle is now a random value * 360 + size

Vector Math Commands:
Most math command take several inputs and a final storage vector name
Sometimes also followed by additional math value

scale <src> <dst> <math> -> <scr> * <math>
add <src1> <src2> <dst> -> add <src2> to <src2>
addScale <src1> <src2> <dst> <math>-> add <src2> * <math> to <src1>
sub <src1> <src2> <dst> -> substract <src2> from <src>
subScale <src1> <src2> <dst> <math>-> substract <src2> * <math> from <src1>
copy <src> <dst> -> Copy <src>
clear <dst> -> set to 0,0,0
wobble <src> <dst> <math> Randomly move src around within cone of <math> degrees
random <dst> Create a random vector with length 1 in any direction
normalize <src> <dst> Normalize a vector so make it length 1
perpendicular <src> <dst> Create a perpendicular vector to <src>
cross <src1> <src2> <dst> Create the cross product of src1xsrc2


Render Commands:
These will render something on the screen using the current state of the variables
sprite <options> -> view aligned image -> origin, shader, color, size, angle
spark <options> -> view aligned spark -> origin, velocity, shader, color, size, width
quad -> fixed aligned sprite -> origin, dir, shader, color, size, angle
beam -> image stretched between 2 points, origin, shader





FX Math:
Fx scripts can use a fair collection of math functions
They are constructed from a number of options

Math operators:
+, -, *, / -> The regular math operans

Math test operators:
Special group of operators that return 0 or 1 depending on a test
< -> ( 0 < 2 ) returns 1 -> 2 smaller than 0
> -> ( 2 > 0 ) returns 1 -> 2 bigger than 0
! -> ( 2 ! 0 ) returns 1 -> 2 unequeal to 0
= -> ( 2 = 2 ) returns 1 -> 2 equal to 2
& -> ( 2 & 2 ) returns 1 -> 2 && 2
| -> ( 2 | 0 ) return 1 -> 2 || 0

The boolean operations only check for not equal to zero, no boolean algebra

Math numbers:
Just regular numbers like 0.112 22 12412

Math Floats:
floats variables like size, width, origin0

Math Vectors:
Vector variables like origin, velocity which will return the vector length

Math Constants:
These are readonly constants to be used in math routines

time -> Time in seconds since the beginning of a map
loop -> Goes from 0 -> 1 during any kind of repeating action in a script
red, green, blue, alpha -> specific color components value in 0,1
pi -> 3.1414155 something
rand -> random value between 0, 1
crand -> random value between -1, 1
lerp -> Goes from 0 -> 1 during the life of an emitter
life -> Amount of life in seconds that an entity got when it was emitted

Math Functions:
These functions can be nested in a math expression with their own expression
so sin( sin ( 3*pi ) ) would be a valid math expression

sqrt( value ) -> Square root
ceil( value ) -> Round values up to next integer 0.3 -> 1
floor( value ) -> Round values down to next integer 0.3 -> 0
sin( value ) -> regular sinus using degrees
cos( value ) -> regular cosinus using degrees
wave( value ) -> sinus type wave but takes 0-1 to complete compared to 0 - 2pi
clip( value ) -> returns value clipped between 0,1 so <0 becomes 0 and > 1 becomes 1

Math Cvars:
This is a special group, if the fx math parser can't find the variable name
It'll try to see if there's a regular q3 cvar with that name and then it'll use that value
So you can use cg_* values or whatever cvar you want

Akhanubis escribió:Variables float con significado particular


size, width y angle (definen propiedades antes de invocar sprite, angleModel, etc)

Variables float auxiliares


t0, t1, t2, t3

Variables vector(X,Y,Z siendo X, Y y Z floats) con significado particular


origin, velocity, dir, angles (definen propiedades antes de invocar sprite, angleModel, etc y también son input de las distintas rutinas del script)

Variables vector auxiliares


v0, v1, v2, v3
Para referirse a una coordenada particular del vector se usa como sufijo la posición de la misma. Es decir, lo que en la mayoría de los lenguajes de programación es v0[i], acá es v0i siendo i 0(X), 1(Y) o 2(Z).

Asignación


No se utiliza ningún operador, por ejemplo, para que el vector dir apunte hacia arriba,es decir, versor (0,0,1), se escribe

Código:

dir0 0
dir1 0
dir2 1

Operadores vectoriales


Hay varios que se entienden, otros que no.
scale multiplica a un vector por un escalar. Utilizando el vector dir anterior, scale dir v0 10 almacena en v0 el vector (0,0,10).
clear setea en (0,0,0) al vector.
wobble devuelve un vector de la misma longitud que el vector src contenido en un cono con vector director src y ángulo de apertura math (aunque no llega a los 360º, no entiendo todavía cómo lo define).



Tipos de renderizados


sprite invoca al renderizado de, claramente, un sprite. Es decir, una imagen 2D que SIEMPRE la vemos de frente. Se parametriza mediante origin, shader, color, size, angle.
spark invoca el renderizado de una chispa (?). También se ve siempre de frente supuestamente. No lo probé. Parámetros: origin, velocity, shader, color, size, width.
quad es igual que sprite con la gran diferencia de que no se ve siempre de frente. Para esto, se define la dirección del vector normal al pleno del sprite (parámetro dir). Sus parámetros son origin, dir (se agrega respecto de sprite), shader, color, size, angle.
beam estira o achica la imagen para inscribirla entre dos puntos. No me cierra con qué parametros lo hace, la guía sólo dice lo siguiente "image stretched between 2 points, origin, shader".

Operadores


No me parece detenerme en esto, es bastante boludo. A lo sumo aclarar que, igual que C, algo igual a 0 es falso, sino es verdadero.

Estructuras de control

Código:

emitter #tiempo {#código}

Crea una partícula que dura #tiempo segundos viva(renderizada en pantalla). En #código se definen todas sus propiedades y se la renderiza. Por ejemplo, se puede definir la propiedad alphaFade que determina en qué instante comenzar a hacer desaparecer la partícula (es decir, reducir linealmente su opacidad hasta llegar a 0). Cuando alphaFade = lerp, la partícula empieza a desaparecer (se observa que aF = 0 implica que comienza a desaparecer ni bien es creada y aF = 1 que desaparece derepente).

http://k.min.us/icb2Mm.jpg

Se observa que mientras aF no llega a ser igual a lerp, la opacidad se mantiene constante en el valor seteado por alpha #opacidad. Una vez alcanzado el valor de lerp, la opacidad disminuye linealmente hasta desaparecer.

Código:

interval #tiempo {#código}

#código se ejecuta cada vez que transcurrió #tiempo segundos.

Código:

distance #distancia {#código}

#código se ejecuta cada vez que se recorrió #distancia unidades de quake. Por ejemplo, usándolo en weapon/rocket/trail, podemos definir cada cuánto hechar humito . En particular, en el caso de rocket/plasma/bfg, distance funciona igual que interval ya que los proyectiles de esas armas realizan MRU (no tienen aceleración), por lo que distance #distancia es igual a interval (#distancia / velocidadDelRocket). La utilidad de distance es para, por ejemplo, trails de entidades que tienen aceleración como granadas(gravedad) o players.

Constantes (en realidad son read-only)


Las únicas que puede costar entender son lerp y life. Cuando uno crea una partícula a partir de un emitter, se le asigna un TTL(vida en segundos, remitirse a la definición de emitter).
life retorna ese tiempo asignado en su creación.
lerp retorna el % (lerp va de 0 a 1) de vida de la partícula transcurrida hasta el momento. Es decir, lerp = #tiempoTranscurridoDesdeCreación / life.

Funciones matemáticas


Una más boluda que la otra. A lo sumo aclarar que
wave(value) = sin(2pi value). Es decir, es un seno de período 1 en lugar de 2pi.
clip(value)

Último script: http://pastebin.com/kZjszvyu
Shaders, texturas y demáses: http://www.sendspace.com/file/yyr152

eze55BP escribió:che chabon tantos graficos tantos graficos porque en la secu cuando los haces te salen mal

_Strelok_ escribió:Aca recopile varios q3mme, entre esos 3 de un gran conocido de las arenas de CPMA, stuhl, los que les guste CPMA lo van a conocer, los que no lo dudo xD, pero bueno, estan buenos algunos, ah y esta el rocket de Diente jajaja:
http://www.mediafire.com/?disd5vkawqi7wba

• q3mme2: este el último de jones
  
• q3mme5: es la mezcolanza que hice para para la peli. Los únicos que recuerdo de ahi son: la explosión de granada y rocket son un mismo script para granada de leglees (el tema es que no sé de dónde lo saqué, lo estuve buscando pero no el original); la rail es de jones; y los efectos de sangre los modifiqué yo buscando copiar no sé qué peli, aunq no me quedó tan bueno

Código:

weapon/lightning/impact {
   // random impact sound

        // wolfcam:  enable quake3 sound settings before playing impact sound
        // so that the sound isn't fps dependent
        t0 s_maxSoundInstances
        t1 s_maxSoundRepeatTime
        command s_maxSoundInstances -1
        command s_maxSoundRepeatTime 50
   soundList {
      sound/weapons/lightning/lg_hit.wav
      sound/weapons/lightning/lg_hit2.wav
      sound/weapons/lightning/lg_hit3.wav
   }
        command s_maxSoundInstances %t0
        command s_maxSoundRepeatTime %t1

   // Hole mark shader decal
   shader   gfx/damage/hole_lg_mrk
   size   5
   decal

   // marca blanca
   shader   flareShader
   alpha   0.5
   color   1 1 0.9
   repeat 5 {
      wobble   dir velocity 1
      size   1 + rand
      emitter "1 + rand*0.3" {
         colorFade 0.7
         Sprite
      }
   }
}

Código:

weapon/lightning/impact {
   // random impact sound

        // wolfcam:  enable quake3 sound settings before playing impact sound
        // so that the sound isn't fps dependent
        t0 s_maxSoundInstances
        t1 s_maxSoundRepeatTime
        command s_maxSoundInstances -1
        command s_maxSoundRepeatTime 50
   soundList {
      sound/weapons/lightning/lg_hit.wav
      sound/weapons/lightning/lg_hit2.wav
      sound/weapons/lightning/lg_hit3.wav
   }
        command s_maxSoundInstances %t0
        command s_maxSoundRepeatTime %t1

   // Hole mark shader decal
   shader   gfx/damage/hole_lg_mrk
   size   5
   decal

   // marca blanca
   shader   flareShader
   alpha   0.9
   color   1 1 1
   repeat 10 {
      wobble   dir velocity 1
      size   1 + rand
      emitter "10" {
         colorFade 0.7
         sprite
      }
   }

   // lluvia
   shader   flareShader
   alpha   0.8
   color   1 1 1
   repeat 5 {
      wobble   dir velocity 20 + rand*20
      scale   velocity velocity 100 + rand*20
      size   1 + rand
      emitter "0.6 + rand*0.3" {
         moveGravity 300
         colorFade 0.7
         Sprite
      }
   }
}

Código:

weapon/rocket/trail {
   // Set the base yellow color
   color   1 0.75 1               // color de la luz que el rocket va dejando debajo

   size   200
   Light

   // The standard smoke puff trail thing
   color   0 0 0                  // color del humo
   alpha   0.4                  // transparencia
   shader   smokePuff
   rotate   360 * rand
   distance 5 {                  // distancia en la que empieza a aparecer el humo
      emitter 2 {
         alphaFade   0         // tiempo de "vida" antes de desaparecer (en 0 desaparece apenas al aparecer)
         size      6 + lerp * 35      // tamaño (con un algoritmo raro q no entiendo :/)
         sprite      cullNear
      }
   }
}

• Granada cpma pk3: http://www.mediafire.com/?ku7q2jahyzusxbz
  
• Humo negro en granada:

Código:

weapon/grenade/trail {
   // The standard smoke puff trail thing
   color   0 0 0
   alpha   0.4
   shader   smokePuff
   angle   360 * rand
   // Emit a sprite every 50 milliseconds
   interval  0.01 {    //con esto se controla la densidad del humo, cada cuántos seg/miliseg aparece el humo: cuánto más bajo el valor, más denso; más alto, mas limpio.
      emitter 2 {      //en el original 0.700 (no me di cuenta que cambie nada)
         alphaFade   0
         size      8 + lerp * 32
         sprite      cullNear
      }
   }
}

Código:

seta cg_oldRail "1" // Rail style (0 = new style = espiral, 1 = old style = rayo + discos)

cg_railQL "1"
cg_railUseOwnColors "1"
cg_railQLRailRingWhiteValue "1"
cg_railNudge "1"

seta color1 "0" // El color del rayo de la rail
seta color2 "25" // El color del espiral o discos externos del rail
seta r_railCoreWidth "0" // Diametro del efecto del nucle en pixels
seta r_railWidth "35" // Diametro del efecto del rayo del rail en pixels, como asi del efecto del impacto
seta r_railSegmentLength "0.50" // Largo de cada segmento del rail en pixels
seta cg_railTrailTime "2000" // Tiempo que queda el rayo visible en ms