Paranoia2/engine/studio.h

795 lines
22 KiB
C
Raw Normal View History

2020-08-31 18:50:41 +02:00
/***
*
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
* Use, distribution, and modification of this source code and/or resulting
* object code is restricted to non-commercial enhancements to products from
* Valve LLC. All other use, distribution, or modification is prohibited
* without written permission from Valve LLC.
*
****/
#ifndef STUDIO_H
#define STUDIO_H
#include "shader.h"
#include "color24.h"
#include "lightlimits.h"
/*
==============================================================================
STUDIO MODELS
Studio models are position independent, so the cache manager can move them.
==============================================================================
*/
// header
#define STUDIO_VERSION 10
#define IDSTUDIOHEADER (('T'<<24)+('S'<<16)+('D'<<8)+'I') // little-endian "IDST"
#define IDSEQGRPHEADER (('Q'<<24)+('S'<<16)+('D'<<8)+'I') // little-endian "IDSQ"
// studio limits
#define MAXSTUDIOVERTS 16384 // max vertices per submodel
#define MAXSTUDIOSKINS 256 // total textures
#define MAXSTUDIOBONES 128 // total bones actually used
#define MAXSTUDIOMODELS 32 // sub-models per model
#define MAXSTUDIOBODYPARTS 32 // body parts per submodel
#define MAXSTUDIOGROUPS 16 // sequence groups (e.g. barney01.mdl, barney02.mdl, e.t.c)
#define MAXSTUDIOCONTROLLERS 32 // max controllers per model
#define MAXSTUDIOATTACHMENTS 64 // max attachments per model
#define MAXSTUDIOBONEWEIGHTS 4 // absolute hardware limit!
#define MAXSTUDIONAME 32 // a part of specs
#define MAXSTUDIOPOSEPARAM 24
#define MAXEVENTSTRING 64
#define MAX_STUDIO_LIGHTMAP_SIZE 256 // must match with engine const!!!
// client-side model flags
#define STUDIO_ROCKET (1<<0) // leave a trail
#define STUDIO_GRENADE (1<<1) // leave a trail
#define STUDIO_GIB (1<<2) // leave a trail
#define STUDIO_ROTATE (1<<3) // rotate (bonus items)
#define STUDIO_TRACER (1<<4) // green split trail
#define STUDIO_ZOMGIB (1<<5) // small blood trail
#define STUDIO_TRACER2 (1<<6) // orange split trail + rotate
#define STUDIO_TRACER3 (1<<7) // purple trail
#define STUDIO_AMBIENT_LIGHT (1<<8) // force to use ambient shading
#define STUDIO_TRACE_HITBOX (1<<9) // always use hitbox trace instead of bbox
#define STUDIO_FORCE_SKYLIGHT (1<<10) // always grab lightvalues from the sky settings (even if sky is invisible)
#define STUDIO_HAS_BUMP (1<<16) // loadtime set
#define STUDIO_STATIC_PROP (1<<29) // hint for engine
#define STUDIO_HAS_BONEINFO (1<<30) // extra info about bones (pose matrix, procedural index etc)
#define STUDIO_HAS_BONEWEIGHTS (1<<31) // yes we got support of bone weighting
// lighting & rendermode options
#define STUDIO_NF_FLATSHADE 0x0001
#define STUDIO_NF_CHROME 0x0002
#define STUDIO_NF_FULLBRIGHT 0x0004
#define STUDIO_NF_NOMIPS 0x0008 // ignore mip-maps
#define STUDIO_NF_SMOOTH 0x0010 // smooth tangent space
#define STUDIO_NF_ADDITIVE 0x0020 // rendering with additive mode
#define STUDIO_NF_MASKED 0x0040 // use texture with alpha channel
#define STUDIO_NF_NORMALMAP 0x0080 // indexed normalmap
#define STUDIO_NF_GLOSSMAP 0x0100 // glossmap
#define STUDIO_NF_GLOSSPOWER 0x0200
#define STUDIO_NF_LUMA 0x0400 // self-illuminate parts
#define STUDIO_NF_ALPHASOLID 0x0800 // use with STUDIO_NF_MASKED to have solid alphatest surfaces for env_static
#define STUDIO_NF_TWOSIDE 0x1000 // render mesh as twosided
#define STUDIO_NF_HEIGHTMAP 0x2000
#define STUDIO_NF_NODRAW (1<<16) // failed to create shader for this mesh
#define STUDIO_NF_NODLIGHT (1<<17) // failed to create dlight shader for this mesh
#define STUDIO_NF_NOSUNLIGHT (1<<18) // failed to create sun light shader for this mesh
#define STUDIO_NF_HAS_ALPHA (1<<20) // external texture has alpha-channel
#define STUDIO_NF_HAS_DETAIL (1<<21) // studiomodels has detail textures
#define STUDIO_NF_COLORMAP (1<<30) // can changed by colormap command
#define STUDIO_NF_UV_COORDS (1<<31) // using half-float coords instead of ST
// motion flags
#define STUDIO_X 0x0001
#define STUDIO_Y 0x0002
#define STUDIO_Z 0x0004
#define STUDIO_XR 0x0008
#define STUDIO_YR 0x0010
#define STUDIO_ZR 0x0020
#define STUDIO_LX 0x0040
#define STUDIO_LY 0x0080
#define STUDIO_LZ 0x0100
#define STUDIO_LXR 0x0200
#define STUDIO_LYR 0x0400
#define STUDIO_LZR 0x0800
#define STUDIO_LINEAR 0x1000
#define STUDIO_QUADRATIC_MOTION 0x2000
#define STUDIO_RESERVED 0x4000 // g-cont. reserved one bit for me
#define STUDIO_TYPES 0x7FFF
#define STUDIO_RLOOP 0x8000 // controller that wraps shortest distance
// bonecontroller types
#define STUDIO_MOUTH 4
// sequence flags
#define STUDIO_LOOPING 0x0001 // ending frame should be the same as the starting frame
#define STUDIO_SNAP 0x0002 // do not interpolate between previous animation and this one
#define STUDIO_DELTA 0x0004 // this sequence "adds" to the base sequences, not slerp blends
#define STUDIO_AUTOPLAY 0x0008 // temporary flag that forces the sequence to always play
#define STUDIO_POST 0x0010 //
#define STUDIO_ALLZEROS 0x0020 // this animation/sequence has no real animation data
#define STUDIO_BLENDPOSE 0x0040 // to differentiate GoldSrc style blending from Source style blending (with pose parameters)
#define STUDIO_CYCLEPOSE 0x0080 // cycle index is taken from a pose parameter index
#define STUDIO_REALTIME 0x0100 // cycle index is taken from a real-time clock, not the animations cycle index
#define STUDIO_LOCAL 0x0200 // sequence has a local context sequence
#define STUDIO_HIDDEN 0x0400 // don't show in default selection views
#define STUDIO_IKRULES 0x0800 // sequence has IK-rules
#define STUDIO_ACTIVITY 0x1000 // Has been updated at runtime to activity index
#define STUDIO_EVENT 0x2000 // Has been updated at runtime to event index
#define STUDIO_WORLD 0x4000 // sequence blends in worldspace
#define STUDIO_LIGHT_FROM_ROOT 0x8000 // get lighting point from root bonepos not from entity origin
// autolayer flags
#define STUDIO_AL_POST 0x0001 //
#define STUDIO_AL_SPLINE 0x0002 // convert layer ramp in/out curve is a spline instead of linear
#define STUDIO_AL_XFADE 0x0004 // pre-bias the ramp curve to compense for a non-1 weight,
// assuming a second layer is also going to accumulate
#define STUDIO_AL_NOBLEND 0x0008 // animation always blends at 1.0 (ignores weight)
#define STUDIO_AL_LOCAL 0x0010 // layer is a local context sequence
#define STUDIO_AL_POSE 0x0020 // layer blends using a pose parameter instead of parent cycle
typedef struct
{
int ident;
int version;
char name[64];
int length;
vec3_t eyeposition; // ideal eye position
vec3_t min; // ideal movement hull size
vec3_t max;
vec3_t bbmin; // clipping bounding box
vec3_t bbmax;
int flags;
int numbones; // bones
int boneindex;
int numbonecontrollers; // bone controllers
int bonecontrollerindex;
int numhitboxes; // complex bounding boxes
int hitboxindex;
int numseq; // animation sequences
int seqindex;
int numseqgroups; // demand loaded sequences
int seqgroupindex;
int numtextures; // raw textures
int textureindex;
int texturedataindex;
int numskinref; // replaceable textures
int numskinfamilies;
int skinindex;
int numbodyparts;
int bodypartindex;
int numattachments; // queryable attachable points
int attachmentindex;
int studiohdr2index;
int soundindex; // UNUSED
int soundgroups; // UNUSED
int soundgroupindex; // UNUSED
int numtransitions; // animation node to animation node transition graph
int transitionindex;
} studiohdr_t;
// extra header to hold more offsets
typedef struct
{
int numposeparameters;
int poseparamindex;
int numikautoplaylocks;
int ikautoplaylockindex;
int numikchains;
int ikchainindex;
int keyvalueindex;
int keyvaluesize;
int numhitboxsets;
int hitboxsetindex;
int unused[6]; // for future expansions
} studiohdr2_t;
// header for demand loaded sequence group data
typedef struct
{
int id;
int version;
char name[64];
int length;
} studioseqhdr_t;
// bone flags
#define BONE_ALWAYS_PROCEDURAL 0x0001 // bone is always procedurally animated
#define BONE_SCREEN_ALIGN_SPHERE 0x0002 // bone aligns to the screen, not constrained in motion.
#define BONE_SCREEN_ALIGN_CYLINDER 0x0004 // bone aligns to the screen, constrained by it's own axis.
#define BONE_JIGGLE_PROCEDURAL 0x0008
#define BONE_FIXED_ALIGNMENT 0x0010 // bone can't spin 360 degrees, all interpolation is normalized around a fixed orientation
#define BONE_USED_MASK (BONE_USED_BY_HITBOX|BONE_USED_BY_ATTACHMENT|BONE_USED_BY_VERTEX|BONE_USED_BY_BONE_MERGE)
#define BONE_USED_BY_ANYTHING BONE_USED_MASK
#define BONE_USED_BY_HITBOX 0x00000100// bone (or child) is used by a hit box
#define BONE_USED_BY_ATTACHMENT 0x00000200// bone (or child) is used by an attachment point
#define BONE_USED_BY_VERTEX 0x00000400// bone (or child) is used by the toplevel model via skinned vertex
#define BONE_USED_BY_BONE_MERGE 0x00000800
// bones
typedef struct
{
char name[MAXSTUDIONAME];// bone name for symbolic links
int parent; // parent bone
int flags; // bone flags
int bonecontroller[6]; // bone controller index, -1 == none
float value[6]; // default DoF values
float scale[6]; // scale for delta DoF values
} mstudiobone_t;
#define STUDIO_PROC_AXISINTERP 1
#define STUDIO_PROC_QUATINTERP 2
#define STUDIO_PROC_AIMATBONE 3
#define STUDIO_PROC_AIMATATTACH 4
#define STUDIO_PROC_JIGGLE 5
typedef struct
{
int control; // local transformation of this bone used to calc 3 point blend
int axis; // axis to check
vec3_t pos[6]; // X+, X-, Y+, Y-, Z+, Z-
vec4_t quat[6]; // X+, X-, Y+, Y-, Z+, Z-
} mstudioaxisinterpbone_t;
typedef struct
{
float inv_tolerance; // 1.0f / radian angle of trigger influence
vec4_t trigger; // angle to match
vec3_t pos; // new position
vec4_t quat; // new angle
} mstudioquatinterpinfo_t;
typedef struct
{
int control; // local transformation to check
int numtriggers;
int triggerindex;
} mstudioquatinterpbone_t;
// extra info for bones
typedef struct
{
float poseToBone[3][4]; // boneweighting reqiures
vec4_t qAlignment;
int proctype;
int procindex; // procedural rule
vec4_t quat; // aligned bone rotation
int reserved[10]; // for future expansions
} mstudioboneinfo_t;
// JIGGLEBONES
#define JIGGLE_IS_FLEXIBLE 0x01
#define JIGGLE_IS_RIGID 0x02
#define JIGGLE_HAS_YAW_CONSTRAINT 0x04
#define JIGGLE_HAS_PITCH_CONSTRAINT 0x08
#define JIGGLE_HAS_ANGLE_CONSTRAINT 0x10
#define JIGGLE_HAS_LENGTH_CONSTRAINT 0x20
#define JIGGLE_HAS_BASE_SPRING 0x40
#define JIGGLE_IS_BOING 0x80 // simple squash and stretch sinusoid "boing"
typedef struct
{
int flags;
// general params
float length; // how from from bone base, along bone, is tip
float tipMass;
// flexible params
float yawStiffness;
float yawDamping;
float pitchStiffness;
float pitchDamping;
float alongStiffness;
float alongDamping;
// angle constraint
float angleLimit; // maximum deflection of tip in radians
// yaw constraint
float minYaw; // in radians
float maxYaw; // in radians
float yawFriction;
float yawBounce;
// pitch constraint
float minPitch; // in radians
float maxPitch; // in radians
float pitchFriction;
float pitchBounce;
// base spring
float baseMass;
float baseStiffness;
float baseDamping;
float baseMinLeft;
float baseMaxLeft;
float baseLeftFriction;
float baseMinUp;
float baseMaxUp;
float baseUpFriction;
float baseMinForward;
float baseMaxForward;
float baseForwardFriction;
// boing
float boingImpactSpeed;
float boingImpactAngle;
float boingDampingRate;
float boingFrequency;
float boingAmplitude;
} mstudiojigglebone_t;
typedef struct
{
int parent;
int aim; // might be bone or attach
vec3_t aimvector;
vec3_t upvector;
vec3_t basepos;
} mstudioaimatbone_t;
// bone controllers
typedef struct
{
int bone; // -1 == 0
int type; // X, Y, Z, XR, YR, ZR, M
float start;
float end;
int rest; // byte index value at rest
int index; // 0-3 user set controller, 4 mouth
} mstudiobonecontroller_t;
// intersection boxes
typedef struct
{
int bone;
int group; // intersection group
vec3_t bbmin; // bounding box
vec3_t bbmax;
} mstudiobbox_t;
typedef struct
{
char name[MAXSTUDIONAME];
int numhitboxes;
int hitboxindex;
} mstudiohitboxset_t;
#ifndef CACHE_USER
#define CACHE_USER
typedef struct cache_user_s
{
void *data; // extradata
} cache_user_t;
#endif
// demand loaded sequence groups
typedef struct
{
char label[MAXSTUDIONAME]; // textual name
char name[64]; // file name
cache_user_t cache; // cache index pointer
int data; // hack for group 0
} mstudioseqgroup_t;
// events
typedef struct mstudioevent_s
{
int frame;
int event;
int type;
char options[MAXEVENTSTRING];
} mstudioevent_t;
#define STUDIO_ATTACHMENT_LOCAL (1<<0) // vectors are filled
// attachment
typedef struct
{
char name[MAXSTUDIONAME];
int flags;
int bone;
vec3_t org; // attachment position
vec3_t vectors[3]; // attachment vectors
} mstudioattachment_t;
#define IK_SELF 1
#define IK_WORLD 2
#define IK_GROUND 3
#define IK_RELEASE 4
#define IK_ATTACHMENT 5
#define IK_UNLATCH 6
typedef struct
{
float scale[6];
unsigned short offset[6];
} mstudioikerror_t;
typedef struct
{
int index;
int type;
int chain;
int bone;
int attachment; // attachment index
int slot; // iktarget slot. Usually same as chain.
float height;
float radius;
float floor;
vec3_t pos;
vec4_t quat;
int ikerrorindex; // compressed IK error
int iStart;
float start; // beginning of influence
float peak; // start of full influence
float tail; // end of full influence
float end; // end of all influence
float contact; // frame footstep makes ground concact
float drop; // how far down the foot should drop when reaching for IK
float top; // top of the foot box
int unused[4]; // for future expansions
} mstudioikrule_t;
typedef struct
{
int chain;
float flPosWeight;
float flLocalQWeight;
int flags;
int unused[4]; // for future expansions
} mstudioiklock_t;
typedef struct
{
int endframe;
int motionflags;
float v0; // velocity at start of block
float v1; // velocity at end of block
float angle; // YAW rotation at end of this blocks movement
vec3_t vector; // movement vector relative to this blocks initial angle
vec3_t position; // relative to start of animation???
} mstudiomovement_t;
// additional info for each animation in sequence blend group or single sequence
typedef struct
{
char label[MAXSTUDIONAME]; // animation label (may be matched with sequence label)
float fps; // frames per second (match with sequence fps or be different)
int flags; // looping/non-looping flags
int numframes; // frames per animation
// piecewise movement
int nummovements; // piecewise movement
int movementindex;
int numikrules;
int ikruleindex; // non-zero when IK data is stored in the mdl
int unused[8]; // for future expansions
} mstudioanimdesc_t;
// autoplaying sequences
typedef struct
{
short iSequence;
short iPose;
int flags;
float start; // beginning of influence
float peak; // start of full influence
float tail; // end of full influence
float end; // end of all influence
} mstudioautolayer_t;
// sequence descriptions
typedef struct
{
char label[MAXSTUDIONAME]; // sequence label
float fps; // frames per second
int flags; // looping/non-looping flags
int activity;
int actweight;
int numevents;
int eventindex;
int numframes; // number of frames per sequence
int weightlistindex; // weightlists
int iklockindex; // IK locks
int motiontype;
int posekeyindex; // index of pose parameter
vec3_t linearmovement;
int autolayerindex; // autolayer descriptions
int keyvalueindex; // local key-values
vec3_t bbmin; // per sequence bounding box
vec3_t bbmax;
int numblends;
int animindex; // mstudioanim_t pointer relative to start of sequence group data
// [blend][bone][X, Y, Z, XR, YR, ZR]
int blendtype[2]; // X, Y, Z, XR, YR, ZR (same as paramindex)
float blendstart[2]; // starting value (same as paramstart)
float blendend[2]; // ending value (same as paramend)
byte groupsize[2]; // 255 x 255 blends should be enough
byte numautolayers; // count of autoplaying layers
byte numiklocks; // IK-locks per sequence
int seqgroup; // sequence group for demand loading
int entrynode; // transition node at entry
int exitnode; // transition node at exit
byte nodeflags; // transition rules (really this is bool)
byte cycleposeindex; // index of pose parameter to use as cycle index
byte fadeintime; // ideal cross fade in time (0.2 secs default) time = (fadeintime / 100)
byte fadeouttime; // ideal cross fade out time (0.2 msecs default) time = (fadeouttime / 100)
int animdescindex; // mstudioanimdesc_t [blend]
} mstudioseqdesc_t;
typedef struct
{
char name[MAXSTUDIONAME];
int flags; // ????
float start; // starting value
float end; // ending value
float loop; // looping range, 0 for no looping, 360 for rotations, etc.
} mstudioposeparamdesc_t;
typedef struct
{
unsigned short offset[6];
} mstudioanim_t;
// animation frames
typedef union
{
struct
{
byte valid;
byte total;
} num;
short value;
} mstudioanimvalue_t;
// body part index
typedef struct
{
char name[64];
int nummodels;
int base;
int modelindex; // index into models array
} mstudiobodyparts_t;
// skin info
typedef struct mstudiotex_s
{
char name[64];
int flags;
int width;
int height;
int index;
} mstudiotexture_t;
// ikinfo
typedef struct
{
int bone;
vec3_t kneeDir; // ideal bending direction (per link, if applicable)
vec3_t unused0; // unused
} mstudioiklink_t;
typedef struct
{
char name[MAXSTUDIONAME];
int linktype;
int numlinks;
int linkindex;
} mstudioikchain_t;
typedef struct
{
byte weight[4];
char bone[4];
} mstudioboneweight_t;
// skin families
// short index[skinfamilies][skinref]
// studio models
typedef struct
{
char name[64];
int type; // UNUSED
float boundingradius; // UNUSED
int nummesh;
int meshindex;
int numverts; // number of unique vertices
int vertinfoindex; // vertex bone info
int vertindex; // vertex vec3_t
int numnorms; // number of unique surface normals
int norminfoindex; // normal bone info
int normindex; // normal vec3_t
int blendvertinfoindex; // boneweighted vertex info
int blendnorminfoindex; // boneweighted normal info
} mstudiomodel_t;
// vec3_t boundingbox[model][bone][2]; // complex intersection info
// meshes
typedef struct
{
int numtris;
int triindex;
int skinref;
int numnorms; // per mesh normals
int normindex; // UNUSED!
} mstudiomesh_t;
typedef struct
{
short vertindex; // index into vertex array
short normindex; // index into normal array
short s,t; // s,t position on skin
} mstudiotrivert_t;
/*
===========================
USER-DEFINED DATA
===========================
*/
// this struct may be expaned by user request
typedef struct vbomesh_s
{
unsigned int skinref; // skin reference
unsigned int numVerts; // trifan vertices count
unsigned int numElems; // trifan elements count
int lightmapnum; // each mesh should use only once atlas page!
unsigned int vbo, vao, ibo; // buffer objects
vec3_t mins, maxs; // right transform to get screencopy
int parentbone; // parent bone to transform AABB
unsigned short uniqueID; // to reject decal drawing
unsigned int cacheSize; // debug info: uploaded cache size for this buffer
} vbomesh_t;
// each mstudiotexture_t has a material
typedef struct mstudiomat_s
{
mstudiotexture_t *pSource; // pointer to original texture
unsigned short gl_diffuse_id; // diffuse texture
unsigned short gl_detailmap_id; // detail texture
unsigned short gl_normalmap_id; // normalmap
unsigned short gl_specular_id; // specular
unsigned short gl_glowmap_id; // self-illuminate parts
unsigned short gl_heightmap_id; // parallax stuff
// this part is shared with matdesc_t
float smoothness; // smoothness factor
float detailScale[2]; // detail texture scales x, y
float reflectScale; // reflection scale for translucent water
float refractScale; // refraction scale for mirrors, windows, water
float aberrationScale; // chromatic abberation
float reliefScale; // relief-mapping
struct matdef_s *effects; // hit, impact, particle effects etc
int flags; // mstudiotexture_t->flags
// cached shadernums
shader_t forwardScene;
shader_t forwardLightSpot;
shader_t forwardLightOmni;
shader_t forwardLightProj;
shader_t deferredScene;
shader_t deferredLight;
shader_t forwardDepth;
unsigned short lastRenderMode; // for catch change render modes
} mstudiomaterial_t;
typedef struct mstudiosurface_s
{
int flags; // match with msurface_t->flags
int texture_step;
short lightextents[2];
unsigned short light_s[MAXLIGHTMAPS];
unsigned short light_t[MAXLIGHTMAPS];
byte lights[MAXDYNLIGHTS];// static lights that affected this face (255 = no lights)
int lightmaptexturenum;
byte styles[MAXLIGHTMAPS];
color24 *samples; // note: this is the actual lightmap data for this surface
color24 *normals; // note: this is the actual deluxemap data for this surface
byte *shadows; // note: occlusion map for this surface
} mstudiosurface_t;
typedef struct
{
vbomesh_t *meshes; // meshes per submodel
int nummesh; // mstudiomodel_t->nummesh
} msubmodel_t;
// triangles
typedef struct mbodypart_s
{
int base; // mstudiobodyparts_t->base
msubmodel_t *models[MAXSTUDIOBODYPARTS]; // submodels per body part
int nummodels; // mstudiobodyparts_t->nummodels
} mbodypart_t;
typedef struct mvbocache_s
{
mstudiosurface_t *surfaces;
int numsurfaces;
mbodypart_t *bodyparts;
int numbodyparts;
bool update_light; // gamma or brightness was changed so we need to reload lightmaps
} mstudiocache_t;
typedef struct mposebone_s
{
matrix3x4 posetobone[MAXSTUDIOBONES];
} mposetobone_t;
#endif//STUDIO_H