fteqw/plugins/models/gltf.c

2259 lines
68 KiB
C
Raw Normal View History

#ifndef GLQUAKE
#define GLQUAKE //this is shit.
#endif
#include "quakedef.h"
#include "../plugin.h"
#include "com_mesh.h"
extern modplugfuncs_t *modfuncs;
#define GLTFMODELS
//'The units for all linear distances are meters.'
//'feh: 1 metre is approx. 26.24671916 qu.'
//if the player is 1.6m tall, and the player's model is around 48qu, then 1m=30qu, which is a slightly nicer number to work with, and 1qu is a really poorly defined unit.
#define GLTFSCALE 30
#ifdef GLTFMODELS
typedef struct json_s
{
const char *bodystart;
const char *bodyend;
struct json_s *parent;
struct json_s *child;
struct json_s *sibling;
struct json_s **childlink;
qboolean used; //set to say when something actually read/walked it, so we can flag unsupported things gracefully
char name[1];
} json_t;
//node destruction
static void JSON_Orphan(json_t *t)
{
if (t->parent)
{
json_t *p = t->parent, **l = &p->child;
while (*l)
{
if (*l == t)
{
*l = t->sibling;
if (*l)
p->childlink = l;
break;
}
l = &(*l)->sibling;
}
t->parent = NULL;
t->sibling = NULL;
}
}
static void JSON_Destroy(json_t *t)
{
while(t->child)
JSON_Destroy(t->child);
JSON_Orphan(t);
free(t);
}
//node creation
static json_t *JSON_CreateNode(json_t *parent, const char *namestart, const char *nameend, const char *bodystart, const char *bodyend)
{
json_t *j;
qboolean dupbody = false;
if (namestart && !nameend)
nameend = namestart+strlen(namestart);
if (bodystart && !bodyend)
{
dupbody = true;
bodyend = bodystart+strlen(bodystart);
}
j = malloc(sizeof(*j) + nameend-namestart + (dupbody?1+bodyend-bodystart:0));
memcpy(j->name, namestart, nameend-namestart);
j->name[nameend-namestart] = 0;
j->bodystart = bodystart;
j->bodyend = bodyend;
j->child = NULL;
j->sibling = NULL;
j->childlink = &j->child;
j->parent = parent;
if (parent)
{
*parent->childlink = j;
parent->childlink = &j->sibling;
j->used = false;
}
else
j->used = true;
if (dupbody)
{
char *bod = j->name + (nameend-namestart)+1;
j->bodystart = bod;
j->bodyend = j->bodystart + (bodyend-bodystart);
memcpy(bod, bodystart, bodyend-bodystart);
bod[bodyend-bodystart] = 0;
}
return j;
}
//node parsing
static void JSON_SkipWhite(const char *msg, int *pos, int max)
{
while (*pos < max && (
msg[*pos] == ' ' ||
msg[*pos] == '\t' ||
msg[*pos] == '\r' ||
msg[*pos] == '\n'
))
*pos+=1;
}
static qboolean JSON_ParseString(char const*msg, int *pos, int max, char const**start, char const** end)
{
if (*pos < max && msg[*pos] == '\"')
{
*pos+=1;
*start = msg+*pos;
while (*pos < max && msg[*pos] != '\"')
*pos+=1;
if (*pos < max && msg[*pos] == '\"')
{
*end = msg+*pos;
*pos+=1;
return true;
}
}
else
{
*start = msg+*pos;
while (*pos < max
&& msg[*pos] != ' '
&& msg[*pos] != '\t'
&& msg[*pos] != '\r'
&& msg[*pos] != '\n'
&& msg[*pos] != ':'
&& msg[*pos] != ','
&& msg[*pos] != '}'
&& msg[*pos] != '{'
&& msg[*pos] != '['
&& msg[*pos] != ']')
{
*pos+=1;
}
*end = msg+*pos;
if (*start != *end)
return true;
}
*end = *start;
return false;
}
static json_t *JSON_Parse(json_t *t, const char *namestart, const char *nameend, const char *json, int *jsonpos, int jsonlen)
{
const char *childstart, *childend;
JSON_SkipWhite(json, jsonpos, jsonlen);
if (*jsonpos < jsonlen)
{
if (json[*jsonpos] == '{')
{
*jsonpos+=1;
JSON_SkipWhite(json, jsonpos, jsonlen);
t = JSON_CreateNode(t, namestart, nameend, NULL, NULL);
while (*jsonpos < jsonlen && json[*jsonpos] == '\"')
{
if (!JSON_ParseString(json, jsonpos, jsonlen, &childstart, &childend))
break;
JSON_SkipWhite(json, jsonpos, jsonlen);
if (*jsonpos < jsonlen && json[*jsonpos] == ':')
{
*jsonpos+=1;
if (!JSON_Parse(t, childstart, childend, json, jsonpos, jsonlen))
break;
}
JSON_SkipWhite(json, jsonpos, jsonlen);
if (*jsonpos < jsonlen && json[*jsonpos] == ',')
{
*jsonpos+=1;
JSON_SkipWhite(json, jsonpos, jsonlen);
continue;
}
break;
}
if (*jsonpos < jsonlen && json[*jsonpos] == '}')
{
*jsonpos+=1;
return t;
}
JSON_Destroy(t);
}
else if (json[*jsonpos] == '[')
{
char idxname[MAX_QPATH];
unsigned int idx = 0;
*jsonpos+=1;
JSON_SkipWhite(json, jsonpos, jsonlen);
t = JSON_CreateNode(t, namestart, nameend, NULL, NULL);
for(;;)
{
Q_snprintf(idxname, sizeof(idxname), "%u", idx++);
if (!JSON_Parse(t, idxname, NULL, json, jsonpos, jsonlen))
break;
if (*jsonpos < jsonlen && json[*jsonpos] == ',')
{
*jsonpos+=1;
JSON_SkipWhite(json, jsonpos, jsonlen);
continue;
}
break;
}
JSON_SkipWhite(json, jsonpos, jsonlen);
if (*jsonpos < jsonlen && json[*jsonpos] == ']')
{
*jsonpos+=1;
return t;
}
JSON_Destroy(t);
}
else
{
if (JSON_ParseString(json, jsonpos, jsonlen, &childstart, &childend))
return JSON_CreateNode(t, namestart, nameend, childstart, childend);
}
}
return NULL;
}
static json_t *JSON_FindChild(json_t *t, const char *child)
{
if (t)
{
size_t nl;
const char *dot = strchr(child, '.');
if (dot)
nl = dot-child;
else
nl = strlen(child);
for (t = t->child; t; t = t->sibling)
{
if (!strncmp(t->name, child, nl) && (t->name[nl] == '.' || !t->name[nl]))
{
child+=nl;
t->used = true;
if (*child == '.')
return JSON_FindChild(t, child+1);
if (!*child)
return t;
break;
}
}
}
return NULL;
}
static json_t *JSON_FindIndexedChild(json_t *t, const char *child, unsigned int idx)
{
char idxname[MAX_QPATH];
if (child)
Q_snprintf(idxname, sizeof(idxname), "%s.%u", child, idx);
else
Q_snprintf(idxname, sizeof(idxname), "%u", idx);
return JSON_FindChild(t, idxname);
}
static qboolean JSON_Equals(json_t *t, const char *child, const char *expected)
{
if (child)
t = JSON_FindChild(t, child);
if (t && t->bodyend-t->bodystart == strlen(expected))
return !strncmp(t->bodystart, expected, t->bodyend-t->bodystart);
return false;
}
#include <inttypes.h>
static qintptr_t JSON_GetInteger(json_t *t, const char *child, int fallback)
{
if (child)
t = JSON_FindChild(t, child);
if (t)
{ //copy it to another buffer. can probably skip that tbh.
char tmp[MAX_QPATH];
size_t l = t->bodyend-t->bodystart;
if (l > MAX_QPATH-1)
l = MAX_QPATH-1;
memcpy(tmp, t->bodystart, l);
tmp[l] = 0;
if (!strcmp(tmp, "false")) //special cases, for booleans
return 0;
if (!strcmp(tmp, "true")) //special cases, for booleans
return 1;
return (qintptr_t)strtoll(tmp, NULL, 0);
}
return fallback;
}
static qintptr_t JSON_GetIndexedInteger(json_t *t, unsigned int idx, int fallback)
{
char idxname[MAX_QPATH];
Q_snprintf(idxname, sizeof(idxname), "%u", idx);
return JSON_GetInteger(t, idxname, fallback);
}
static double JSON_GetFloat(json_t *t, const char *child, double fallback)
{
if (child)
t = JSON_FindChild(t, child);
if (t)
{ //copy it to another buffer. can probably skip that tbh.
char tmp[MAX_QPATH];
size_t l = t->bodyend-t->bodystart;
if (l > MAX_QPATH-1)
l = MAX_QPATH-1;
memcpy(tmp, t->bodystart, l);
tmp[l] = 0;
return atof(tmp);
}
return fallback;
}
static double JSON_GetIndexedFloat(json_t *t, unsigned int idx, double fallback)
{
char idxname[MAX_QPATH];
Q_snprintf(idxname, sizeof(idxname), "%u", idx);
return JSON_GetFloat(t, idxname, fallback);
}
static void JSON_GetPath(json_t *t, qboolean ignoreroot, char *buffer, size_t buffersize)
{
if (t->parent && (t->parent->parent || !ignoreroot))
{
JSON_GetPath(t->parent, ignoreroot, buffer, buffersize);
Q_strlcat(buffer, ".", buffersize);
}
Q_strlcat(buffer, t->name, buffersize);
}
static void JSON_WarnUnused(json_t *t, int *warnlimit)
{
if (!t)
return;
if (t->used)
{
for (t = t->child; t; t = t->sibling)
JSON_WarnUnused(t, warnlimit);
}
else
{
char path[8192];
*path = 0;
JSON_GetPath(t, false, path, sizeof(path));
if ((*warnlimit) --> 0)
Con_DPrintf(CON_WARNING"GLTF property %s was not used\n", path);
}
}
static void JSON_FlagAsUsed(json_t *t, const char *child)
{
if (child)
{
t = JSON_FindChild(t, child);
if (!t)
return;
}
t->used = true;
for (t = t->child; t; t = t->sibling)
JSON_FlagAsUsed(t, NULL);
}
static void JSON_WarnIfChild(json_t *t, const char *child, int *warnlimit)
{
t = JSON_FindChild(t, child);
if (t)
{
char path[8192];
*path = 0;
JSON_GetPath(t, false, path, sizeof(path));
if ((*warnlimit) --> 0)
Con_Printf(CON_WARNING"Standard feature %s is not supported\n", path);
JSON_FlagAsUsed(t, NULL);
}
}
static unsigned int FromBase64(char c)
{
if (c >= 'A' && c <= 'Z')
return 0+(c-'A');
if (c >= 'a' && c <= 'z')
return 26+(c-'a');
if (c >= '0' && c <= '9')
return 52+(c-'0');
if (c == '+')
return 62;
if (c == '/')
return 63;
return 64;
}
//fancy parsing of content
static void *JSON_MallocDataURI(json_t *t, size_t *outlen)
{
size_t bl = t->bodyend-t->bodystart;
if (bl >= 5 && !strncmp(t->bodystart, "data:", 5))
{
const char *mimestart = t->bodystart+5;
const char *mimeend;
const char *encstart;
const char *encend;
const char *in;
char *out, *r;
for (mimeend = mimestart; *mimeend && mimeend < t->bodyend; mimeend++)
{
if (*mimeend == ';') //start of encoding
break;
if (*mimeend == ',') //start of data
break;
}
if (*mimeend == ';')
{
for (encend = encstart = mimeend+1; *encend && encend < t->bodyend; encend++)
{
if (*encend == ',') //start of data
break;
}
}
else
encstart = encend = mimeend;
if (*encend == ',' && encend < t->bodyend)
{
in = encend+1;
if (encend-encstart == 6 && !strncmp(encstart, "base64", 6))
{
//base64
r = out = malloc(((t->bodyend-in)*3)/4 + 1);
while (in+3 < t->bodyend)
{
unsigned int c1, c2, c3, c4;
c1 = FromBase64(*in++);
c2 = FromBase64(*in++);
if (c1 >= 64 || c2 >= 64)
break;
*out++ = (c1<<2) | (c2>>4);
c3 = FromBase64(*in++);
if (c3 >= 64)
break;
*out++ = (c2<<4) | (c3>>2);
c4 = FromBase64(*in++);
if (c3 >= 64)
break;
*out++ = (c3<<6) | (c4>>0);
}
*outlen = out-r;
*out = 0;
return r;
}
else if (encend == encstart)
{ //url encoding. yuck, sod off.
}
}
}
return NULL;
}
static size_t JSON_ReadBody(json_t *t, char *out, size_t outsize)
{
size_t bodysize;
if (!t)
{
if (out)
*out = 0;
return 0;
}
if (out)
{
bodysize = t->bodyend-t->bodystart;
if (bodysize > outsize-1)
bodysize = outsize-1;
memcpy(out, t->bodystart, bodysize);
out[bodysize] = 0;
}
return t->bodyend-t->bodystart;
}
//glTF 1.0 and 2.0 differ in that 1 uses names and 2 uses indexes. There's also some significant differences with materials.
//we only support 2.0
Added pm_pground cvar for compat with mvdsv/ezquake. Do not use it with NQ mods however, as the QC will interfere with the onground state (QW mods are okay). Added Z_EXT_PF_ONGROUND + Z_EXT_PF_SOLID for compat (not enabled serverside due to conflicts with pext - just a define away). Fixed bug with loading screens switching sizes part way through loading. Added hexen2 rain effect. Fix hexen2 model texture alphas not working. Fix potential linux crash from excessively long stdin lines. Added cl_rollalpha cvar. Fixed quirk where the player would slide along the base of steep walls/slopes. Tweaked PM_NudgePosition to be more precise, giving more reliable prediction. Fixed fread qc builtin. Tweaked random() builtin to bias slightly away from 0, so that nextthink=random()*foo; will never cause statue-monsters. Check for GL_WEBGL_depth_texture instead of just GL_OES_depth_texture, to fix compressedTex2d errors in firefox. Second attempt at blocking invariant keyword with mesa. Use xrandr for gamma where possible. This prevents reading stale XF86 gamma ramps and restoring those invalid ramps when quitting. Try to grab mouse pointers slightly faster in x11. Don't call XIFreeDeviceInfo if XIQueryDevice returned NULL. Document parm_string and startspot qc globals. Fix possible infinite loop from physics frames. QTV: stripped most of the old plugin code (because really, who has a browser that still supports either ActiveX or NPAPI). Fixed up emscripten port references. QTV: fix bug with protocol extensions not being reported to viewers. QTV: use binary websockets instead of text. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5419 fc73d0e0-1445-4013-8a0c-d673dee63da5
2019-03-01 22:39:30 +00:00
//articulated models are handled by loading them as skeletal (should probably optimise the engine for this usecase)
//we don't support skeletal models either right now.
//buffers are raw blobs that can come from multiple different sources
struct gltf_buffer
{
qboolean loaded;
qboolean malloced;
void *data;
size_t length;
};
typedef struct gltf_s
{
struct model_s *mod;
unsigned int numsurfaces;
json_t *r;
int *bonemap;//[MAX_BONES]; //remap skinned bones. I hate that we have to do this.
struct gltfbone_s
{
char name[32];
int parent;
int camera;
double amatrix[16];
double inverse[16];
struct
{
double rmatrix[16]; //gah
double quat[4], scale[3], trans[3]; //annoying smeg
} rel;
struct {
struct gltf_accessor *input;
struct gltf_accessor *output;
} *rot, *scale, *translation;
} *bones;//[MAX_BONES];
unsigned int numbones;
int warnlimit; //don't spam warnings. this is a loader, not a spammer
struct gltf_buffer buffers[64];
} gltf_t;
static void GLTF_RelativePath(const char *base, const char *relative, char *out, size_t outsize)
{
size_t t;
const char *sep;
const char *end = base;
if (*relative == '/')
{
relative++;
}
else
{
for (sep = end; *sep; sep++)
{
if (*sep == '/' || *sep == '\\')
end = sep+1;
}
}
while (!strncmp(relative, "../", 3))
{
if (end > base)
{
end--;
while (end > base)
{
end--;
if (*end == '/' || *end == '\\')
{
relative += 3;
end++;
break;
}
}
}
else
break;
}
outsize--; //for the null
t = end-base;
if (t > outsize)
t = outsize;
memcpy(out, base, t);
out += t;
outsize -= t;
Added pm_pground cvar for compat with mvdsv/ezquake. Do not use it with NQ mods however, as the QC will interfere with the onground state (QW mods are okay). Added Z_EXT_PF_ONGROUND + Z_EXT_PF_SOLID for compat (not enabled serverside due to conflicts with pext - just a define away). Fixed bug with loading screens switching sizes part way through loading. Added hexen2 rain effect. Fix hexen2 model texture alphas not working. Fix potential linux crash from excessively long stdin lines. Added cl_rollalpha cvar. Fixed quirk where the player would slide along the base of steep walls/slopes. Tweaked PM_NudgePosition to be more precise, giving more reliable prediction. Fixed fread qc builtin. Tweaked random() builtin to bias slightly away from 0, so that nextthink=random()*foo; will never cause statue-monsters. Check for GL_WEBGL_depth_texture instead of just GL_OES_depth_texture, to fix compressedTex2d errors in firefox. Second attempt at blocking invariant keyword with mesa. Use xrandr for gamma where possible. This prevents reading stale XF86 gamma ramps and restoring those invalid ramps when quitting. Try to grab mouse pointers slightly faster in x11. Don't call XIFreeDeviceInfo if XIQueryDevice returned NULL. Document parm_string and startspot qc globals. Fix possible infinite loop from physics frames. QTV: stripped most of the old plugin code (because really, who has a browser that still supports either ActiveX or NPAPI). Fixed up emscripten port references. QTV: fix bug with protocol extensions not being reported to viewers. QTV: use binary websockets instead of text. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5419 fc73d0e0-1445-4013-8a0c-d673dee63da5
2019-03-01 22:39:30 +00:00
//FIXME: uris should be percent-decoded here.
t = strlen(relative);
if (t > outsize)
t = outsize;
memcpy(out, relative, t);
out += t;
outsize -= t;
*out = 0;
}
static struct gltf_buffer *GLTF_GetBufferData(gltf_t *gltf, int bufferidx)
{
json_t *b = JSON_FindIndexedChild(gltf->r, "buffers", bufferidx);
json_t *uri = JSON_FindChild(b, "uri");
size_t length = JSON_GetInteger(b, "byteLength", 0);
struct gltf_buffer *out;
// JSON_WarnIfChild(b, "name");
// JSON_WarnIfChild(b, "extensions");
// JSON_WarnIfChild(b, "extras");
if (bufferidx < 0 || bufferidx >= countof(gltf->buffers))
return NULL;
out = &gltf->buffers[bufferidx];
//we may have been through here before...
if (out->loaded)
return out->data?out:NULL;
out->loaded = true;
if (uri)
{
out->malloced = true;
out->data = JSON_MallocDataURI(uri, &out->length);
if (!out->data)
{
//read a file from disk.
vfsfile_t *f;
char uritext[MAX_QPATH];
char filename[MAX_QPATH];
JSON_ReadBody(uri, uritext, sizeof(uritext));
GLTF_RelativePath(gltf->mod->name, uritext, filename, sizeof(filename));
f = modfuncs->OpenVFS(filename, "rb", FS_GAME);
if (f)
{
out->length = VFS_GETLEN(f);
out->length = min(out->length, length);
out->data = malloc(length);
VFS_READ(f, out->data, length);
VFS_CLOSE(f);
}
Added pm_pground cvar for compat with mvdsv/ezquake. Do not use it with NQ mods however, as the QC will interfere with the onground state (QW mods are okay). Added Z_EXT_PF_ONGROUND + Z_EXT_PF_SOLID for compat (not enabled serverside due to conflicts with pext - just a define away). Fixed bug with loading screens switching sizes part way through loading. Added hexen2 rain effect. Fix hexen2 model texture alphas not working. Fix potential linux crash from excessively long stdin lines. Added cl_rollalpha cvar. Fixed quirk where the player would slide along the base of steep walls/slopes. Tweaked PM_NudgePosition to be more precise, giving more reliable prediction. Fixed fread qc builtin. Tweaked random() builtin to bias slightly away from 0, so that nextthink=random()*foo; will never cause statue-monsters. Check for GL_WEBGL_depth_texture instead of just GL_OES_depth_texture, to fix compressedTex2d errors in firefox. Second attempt at blocking invariant keyword with mesa. Use xrandr for gamma where possible. This prevents reading stale XF86 gamma ramps and restoring those invalid ramps when quitting. Try to grab mouse pointers slightly faster in x11. Don't call XIFreeDeviceInfo if XIQueryDevice returned NULL. Document parm_string and startspot qc globals. Fix possible infinite loop from physics frames. QTV: stripped most of the old plugin code (because really, who has a browser that still supports either ActiveX or NPAPI). Fixed up emscripten port references. QTV: fix bug with protocol extensions not being reported to viewers. QTV: use binary websockets instead of text. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5419 fc73d0e0-1445-4013-8a0c-d673dee63da5
2019-03-01 22:39:30 +00:00
else
Con_Printf(CON_WARNING"%s: Unable to read buffer file %s\n", gltf->mod->name, filename);
}
}
return out->data?out:NULL;
}
//buffer views are aka VBOs. each has its own VBO data type (vbo/ebo), and can be uploaded as-is.
struct gltf_bufferview
{
void *data;
size_t length;
int bytestride;
};
static qboolean GLTF_GetBufferViewData(gltf_t *gltf, int bufferview, struct gltf_bufferview *view)
{
struct gltf_buffer *buf;
json_t *bv = JSON_FindIndexedChild(gltf->r, "bufferViews", bufferview);
size_t offset;
if (!bv)
return false;
buf = GLTF_GetBufferData(gltf, JSON_GetInteger(bv, "buffer", 0));
if (!buf)
return false;
offset = JSON_GetInteger(bv, "byteOffset", 0);
view->data = (char*)buf->data + offset;
view->length = JSON_GetInteger(bv, "byteLength", 0); //required
view->bytestride = JSON_GetInteger(bv, "byteStride", 0);
if (offset + view->length > buf->length)
return false;
JSON_FlagAsUsed(bv, "target"); //required, but not useful for us.
JSON_FlagAsUsed(bv, "name");
// JSON_WarnIfChild(bv, "extensions");
// JSON_WarnIfChild(bv, "extras");
return true;
}
//accessors are basically VAs blocks that refer inside a bufferview/VBO.
struct gltf_accessor
{
void *data;
size_t length;
size_t bytestride;
int componentType; //5120 BYTE, 5121 UNSIGNED_BYTE, 5122 SHORT, 5123 UNSIGNED_SHORT, 5125 UNSIGNED_INT, 5126 FLOAT
qboolean normalized;
int count;
int type; //1,2,3,4 says component count, 256|(4,9,16) for square matricies...
double mins[16];
double maxs[16];
};
static qboolean GLTF_GetAccessor(gltf_t *gltf, int accessorid, struct gltf_accessor *out)
{
struct gltf_bufferview bv;
json_t *a, *mins, *maxs;
size_t offset;
int j;
memset(out, 0, sizeof(*out));
a = JSON_FindIndexedChild(gltf->r, "accessors", accessorid);
if (!a)
return false;
if (!GLTF_GetBufferViewData(gltf, JSON_GetInteger(a, "bufferView", 0), &bv))
return false;
offset = JSON_GetInteger(a, "byteOffset", 0);
if (offset > bv.length)
return false;
out->length = bv.length - offset;
out->bytestride = bv.bytestride;
out->componentType = JSON_GetInteger(a, "componentType", 0);
out->normalized = JSON_GetInteger(a, "normalized", false);
out->count = JSON_GetInteger(a, "count", 0);
if (JSON_Equals(a, "type", "SCALAR"))
out->type = (1<<8) | 1;
else if (JSON_Equals(a, "type", "VEC2"))
out->type = (1<<8) | 2;
else if (JSON_Equals(a, "type", "VEC3"))
out->type = (1<<8) | 3;
else if (JSON_Equals(a, "type", "VEC4"))
out->type = (1<<8) | 4;
else if (JSON_Equals(a, "type", "MAT2"))
out->type = (2<<8) | 2;
else if (JSON_Equals(a, "type", "MAT3"))
out->type = (3<<8) | 3;
else if (JSON_Equals(a, "type", "MAT4"))
out->type = (4<<8) | 4;
else
{
if (gltf->warnlimit --> 0)
Con_Printf(CON_WARNING"%s: glTF2 unsupported type\n", gltf->mod->name);
out->type = 1;
}
if (!out->bytestride)
{
out->bytestride = (out->type & 0xff) * (out->type>>8);
switch(out->componentType)
{
default:
if (gltf->warnlimit --> 0)
Con_Printf(CON_WARNING"GLTF_GetAccessor: %s: glTF2 unsupported componentType (%i)\n", gltf->mod->name, out->componentType);
case 5120: //BYTE
case 5121: //UNSIGNED_BYTE
break;
case 5122: //SHORT
case 5123: //UNSIGNED_SHORT
out->bytestride *= 2;
break;
case 5125: //UNSIGNED_INT
case 5126: //FLOAT
out->bytestride *= 4;
break;
}
}
mins = JSON_FindChild(a, "min");
maxs = JSON_FindChild(a, "max");
for (j = 0; j < (out->type>>8)*(out->type&0xff); j++)
{ //'must' be set in various situations.
out->mins[j] = JSON_GetIndexedInteger(mins, j, 0);
out->maxs[j] = JSON_GetIndexedInteger(maxs, j, 0);
}
// JSON_WarnIfChild(a, "sparse");
// JSON_WarnIfChild(a, "name");
// JSON_WarnIfChild(a, "extensions");
// JSON_WarnIfChild(a, "extras");
out->data = (char*)bv.data + offset;
return true;
}
static void GLTF_AccessorToTangents(gltf_t *gltf, vec3_t *norm, vec3_t **sdir, vec3_t **tdir, size_t outverts, struct gltf_accessor *a)
{ //input MUST be a single float4
//output is two vec3s. wasteful perhaps.
vec3_t *os = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(*os) * 3 * outverts);
vec3_t *ot = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(*ot) * 3 * outverts);
char *in = a->data;
size_t v, c;
*sdir = os;
*tdir = ot;
if ((a->type&0xff) != 4)
return;
switch(a->componentType)
{
default:
if (gltf->warnlimit --> 0)
Con_Printf(CON_WARNING"GLTF_AccessorToTangents: %s: glTF2 unsupported componentType (%i)\n", gltf->mod->name, a->componentType);
case 0:
memset(os, 0, sizeof(*os) * outverts);
memset(ot, 0, sizeof(*ot) * outverts);
break;
// case 5120: //BYTE
// case 5121: //UNSIGNED_BYTE
// case 5122: //SHORT
// case 5123: //UNSIGNED_SHORT
// case 5125: //UNSIGNED_INT
case 5126: //FLOAT
for (v = 0; v < outverts; v++)
{
for (c = 0; c < 3; c++)
os[v][c] = ((float*)in)[c];
//bitangent = cross(normal, tangent.xyz) * tangent.w
ot[v][0] = (norm[v][1]*os[v][2] - norm[v][2]*os[v][1]) * ((float*)in)[3];
ot[v][1] = (norm[v][2]*os[v][0] - norm[v][0]*os[v][2]) * ((float*)in)[3];
ot[v][2] = (norm[v][0]*os[v][1] - norm[v][1]*os[v][0]) * ((float*)in)[3];
in += a->bytestride;
}
break;
}
}
static void *GLTF_AccessorToDataF(gltf_t *gltf, size_t outverts, unsigned int outcomponents, struct gltf_accessor *a)
{
float *ret = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(*ret) * outcomponents * outverts), *o;
char *in = a->data;
int c, ic = a->type&0xff;
if (ic > outcomponents)
ic = outcomponents;
o = ret;
switch(a->componentType)
{
default:
if (gltf->warnlimit --> 0)
Con_Printf(CON_WARNING"GLTF_AccessorToDataF: %s: glTF2 unsupported componentType (%i)\n", gltf->mod->name, a->componentType);
case 0:
memset(ret, 0, sizeof(*ret) * outcomponents * outverts);
break;
case 5120: //BYTE
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = max(-1.0, ((char*)in)[c] / 127.0); //negative values are larger, but we want to allow 1.0
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;
case 5121: //UNSIGNED_BYTE
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = ((unsigned char*)in)[c] / 255.0;
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;
case 5122: //SHORT
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = max(-1.0, ((signed short*)in)[c] / 32767.0); //negative values are larger, but we want to allow 1.0
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;
case 5123: //UNSIGNED_SHORT
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = ((unsigned short*)in)[c] / 65535.0;
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;
case 5125: //UNSIGNED_INT
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = ((unsigned int*)in)[c] / (double)~0u; //stupid format to use. will be lossy.
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;
case 5126: //FLOAT
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = ((float*)in)[c];
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;
}
return ret;
}
static void *GLTF_AccessorToDataUB(gltf_t *gltf, size_t outverts, unsigned int outcomponents, struct gltf_accessor *a)
{ //only used for colour, with fallback to float, so only UNSIGNED_BYTE needs to work.
unsigned char *ret = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(*ret) * outcomponents * outverts), *o;
char *in = a->data;
int c, ic = a->type&0xff;
if (ic > outcomponents)
ic = outcomponents;
o = ret;
switch(a->componentType)
{
default:
if (gltf->warnlimit --> 0)
Con_Printf(CON_WARNING"GLTF_AccessorToDataUB: %s: glTF2 unsupported componentType (%i)\n", gltf->mod->name, a->componentType);
case 0:
memset(ret, 0, sizeof(*ret) * outcomponents * outverts);
break;
// case 5120: //BYTE
case 5121: //UNSIGNED_BYTE
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = ((unsigned char*)in)[c];
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;
// case 5122: //SHORT
// case 5123: //UNSIGNED_SHORT
// case 5125: //UNSIGNED_INT
/* case 5126: //FLOAT
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = ((float*)in)[c];
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;*/
}
return ret;
}
static void *GLTF_AccessorToDataBone(gltf_t *gltf, size_t outverts, struct gltf_accessor *a)
{ //input should only be ubytes||ushorts.
const unsigned int outcomponents = 4;
boneidx_t *ret = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(*ret) * outcomponents * outverts), *o;
char *in = a->data;
int c, ic = a->type&0xff;
if (ic > outcomponents)
ic = outcomponents;
o = ret;
switch(a->componentType)
{
default:
if (gltf->warnlimit --> 0)
Con_Printf(CON_WARNING"GLTF_AccessorToDataUB: %s: glTF2 unsupported componentType (%i)\n", gltf->mod->name, a->componentType);
case 0:
memset(ret, 0, sizeof(*ret) * outcomponents * outverts);
break;
// case 5120: //BYTE
case 5121: //UNSIGNED_BYTE
while(outverts --> 0)
{
unsigned char v;
for (c = 0; c < ic; c++)
{
v = ((unsigned char*)in)[c];
o[c] = gltf->bonemap[v];
}
for (; c < outcomponents; c++)
o[c] = gltf->bonemap[0];
o += outcomponents;
in += a->bytestride;
}
break;
case 5122: //SHORT
case 5123: //UNSIGNED_SHORT
while(outverts --> 0)
{
unsigned short v;
for (c = 0; c < ic; c++)
{
v = ((unsigned short*)in)[c];
if (v > MAX_BONES)
v = 0;
o[c] = gltf->bonemap[v];
}
for (; c < outcomponents; c++)
o[c] = gltf->bonemap[0];
o += outcomponents;
in += a->bytestride;
}
break;
//the spec doesn't require these.
// case 5125: //UNSIGNED_INT
/* case 5126: //FLOAT
while(outverts --> 0)
{
for (c = 0; c < ic; c++)
o[c] = ((float*)in)[c];
for (; c < outcomponents; c++)
o[c] = 0;
o += outcomponents;
in += a->bytestride;
}
break;*/
}
return ret;
}
void TransformArrayD(vecV_t *data, size_t vcount, double matrix[])
{
while (vcount --> 0)
{
vec3_t t;
VectorCopy((*data), t);
(*data)[0] = DotProduct(t, (matrix+0)) + matrix[0+3];
(*data)[1] = DotProduct(t, (matrix+4)) + matrix[4+3];
(*data)[2] = DotProduct(t, (matrix+8)) + matrix[8+3];
data++;
}
}
void TransformArrayA(vec3_t *data, size_t vcount, double matrix[])
{
vec3_t t;
float mag;
while (vcount --> 0)
{
t[0] = DotProduct((*data), (matrix+0));
t[1] = DotProduct((*data), (matrix+4));
t[2] = DotProduct((*data), (matrix+8));
//scaling is bad for axis.
mag = DotProduct(t,t);
if (mag)
{
mag = 1/sqrt(mag);
VectorScale(t, mag, t);
}
VectorCopy(t, (*data));
data++;
}
}
static texid_t GLTF_LoadImage(gltf_t *gltf, int imageidx, unsigned int flags)
{
size_t size;
texid_t ret = r_nulltex;
json_t *image = JSON_FindIndexedChild(gltf->r, "images", imageidx);
json_t *uri = JSON_FindChild(image, "uri");
json_t *mimeType = JSON_FindChild(image, "mimeType");
int bufferView = JSON_GetInteger(image, "bufferView", -1);
char uritext[MAX_QPATH];
char filename[MAX_QPATH];
void *mem;
struct gltf_bufferview view;
//potentially valid mime types:
//image/png
//image/vnd-ms.dds (MSFT_texture_dds)
(void)mimeType;
*uritext = 0;
if (uri)
{
mem = JSON_MallocDataURI(uri, &size);
if (mem)
{
JSON_GetPath(image, false, uritext, sizeof(uritext));
ret = modfuncs->GetTexture(uritext, NULL, flags, mem, NULL, size, 0, TF_INVALID);
free(mem);
}
else
{
JSON_ReadBody(uri, uritext, sizeof(uritext));
GLTF_RelativePath(gltf->mod->name, uritext, filename, sizeof(filename));
ret = modfuncs->GetTexture(filename, NULL, flags, NULL, NULL, 0, 0, TF_INVALID);
}
}
else if (bufferView >= 0)
{
if (GLTF_GetBufferViewData(gltf, bufferView, &view))
{
JSON_GetPath(image, false, uritext, sizeof(uritext));
ret = modfuncs->GetTexture(uritext, NULL, flags, view.data, NULL, view.length, 0, TF_INVALID);
}
}
return ret;
}
static texid_t GLTF_LoadTexture(gltf_t *gltf, int texture, unsigned int flags)
{
json_t *tex = JSON_FindIndexedChild(gltf->r, "textures", texture);
json_t *sampler = JSON_FindIndexedChild(gltf->r, "samplers", JSON_GetInteger(tex, "sampler", -1));
int magFilter = JSON_GetInteger(sampler, "magFilter", 0);
int minFilter = JSON_GetInteger(sampler, "minFilter", 0);
int wrapS = JSON_GetInteger(sampler, "wrapS", 10497);
int wrapT = JSON_GetInteger(sampler, "wrapT", 10497);
int source;
JSON_FlagAsUsed(sampler, "name");
JSON_FlagAsUsed(sampler, "extensions");
(void)minFilter;
switch(magFilter)
{
default:
break;
case 9728: //NEAREST
flags |= IF_NOMIPMAP|IF_NEAREST;
break;
case 9729: //LINEAR
flags |= IF_NOMIPMAP|IF_LINEAR;
break;
case 9984: // NEAREST_MIPMAP_NEAREST
case 9986: // NEAREST_MIPMAP_LINEAR
flags |= IF_NEAREST;
break;
case 9985: // LINEAR_MIPMAP_NEAREST
case 9987: // LINEAR_MIPMAP_LINEAR
flags |= IF_LINEAR;
break;
}
if (wrapS == 33071 || wrapT == 33071)
flags |= IF_CLAMP;
flags |= IF_NOREPLACE;
source = JSON_GetInteger(tex, "source", -1);
source = JSON_GetInteger(tex, "extensions.MSFT_texture_dds.source", source); //load a dds instead, if one is available.
return GLTF_LoadImage(gltf, source, flags);
}
static galiasskin_t *GLTF_LoadMaterial(gltf_t *gltf, int material, qboolean vertexcolours)
{
qboolean doubleSided;
int alphaMode;
double alphaCutoff;
char shader[8192];
char alphaCutoffmodifier[128];
json_t *mat = JSON_FindIndexedChild(gltf->r, "materials", material);
galiasskin_t *ret;
json_t *nam, *unlit, *pbrsg, *pbrmr, *blinn;
nam = JSON_FindChild(mat, "name");
unlit = JSON_FindChild(mat, "extensions.KHR_materials_unlit");
pbrsg = JSON_FindChild(mat, "extensions.KHR_materials_pbrSpecularGlossiness");
pbrmr = JSON_FindChild(mat, "pbrMetallicRoughness");
blinn = JSON_FindChild(mat, "extensions.KHR_materials_cmnBlinnPhong");
doubleSided = JSON_GetInteger(mat, "doubleSided", false);
alphaCutoff = JSON_GetFloat(mat, "alphaCutoff", 0.5);
if (JSON_Equals(mat, "alphaMode", "MASK"))
alphaMode = 1;
else if (JSON_Equals(mat, "alphaMode", "BLEND"))
alphaMode = 2;
else //if (JSON_Equals(mat, "alphaMode", "OPAQUE"))
alphaMode = 0;
ret = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(*ret));
ret->numframes = 1;
ret->skinspeed = 0.1;
ret->frame = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(*ret->frame));
if (nam)
JSON_ReadBody(nam, ret->frame->shadername, sizeof(ret->frame->shadername));
else if (mat)
JSON_GetPath(mat, false, ret->frame->shadername, sizeof(ret->frame->shadername));
else
Q_snprintf(ret->frame->shadername, sizeof(ret->frame->shadername), "%i", material);
if (alphaMode == 1)
Q_snprintf(alphaCutoffmodifier, sizeof(alphaCutoffmodifier), "#ALPHATEST=>%f", alphaCutoff);
else
*alphaCutoffmodifier = 0;
if (unlit)
{ //if this extension was present, then we don't get ANY lighting info.
int albedo = JSON_GetInteger(pbrmr, "baseColorTexture.index", -1); //.rgba
ret->frame->texnums.base = GLTF_LoadTexture(gltf, albedo, 0);
Q_snprintf(shader, sizeof(shader),
"{\n"
"surfaceparm nodlight\n"
"%s"//cull
"program default2d%s\n" //fixme: there's no gpu skeletal stuff with this prog
"{\n"
"map $diffuse\n"
"%s" //blend
"%s" //rgbgen
"}\n"
"fte_basefactor %f %f %f %f\n"
"}\n",
doubleSided?"cull disable\n":"",
alphaCutoffmodifier,
(alphaMode==1)?"":(alphaMode==2)?"blendfunc blend\n":"",
vertexcolours?"rgbgen vertex\nalphagen vertex\n":"",
JSON_GetFloat(pbrmr, "baseColorFactor.0", 1),
JSON_GetFloat(pbrmr, "baseColorFactor.1", 1),
JSON_GetFloat(pbrmr, "baseColorFactor.2", 1),
JSON_GetFloat(pbrmr, "baseColorFactor.3", 1)
);
}
else if (blinn)
{
Con_DPrintf(CON_WARNING"%s: KHR_materials_cmnBlinnPhong implemented according to draft spec\n", gltf->mod->name);
ret->frame->texnums.base = GLTF_LoadTexture(gltf, JSON_GetInteger(pbrsg, "diffuseTexture.index", -1), 0);
ret->frame->texnums.specular = GLTF_LoadTexture(gltf, JSON_GetInteger(pbrsg, "specularGlossinessTexture.index", -1), 0);
//you wouldn't normally want this, but we have separate factors so lack of a texture is technically valid.
if (!ret->frame->texnums.base)
ret->frame->texnums.base = modfuncs->GetTexture("$whiteimage", NULL, IF_NOMIPMAP|IF_NOPICMIP|IF_NEAREST|IF_NOGAMMA, NULL, NULL, 0, 0, TF_INVALID);
if (!ret->frame->texnums.specular)
ret->frame->texnums.specular = modfuncs->GetTexture("$whiteimage", NULL, IF_NOMIPMAP|IF_NOPICMIP|IF_NEAREST|IF_NOGAMMA, NULL, NULL, 0, 0, TF_INVALID);
Q_snprintf(shader, sizeof(shader),
"{\n"
"%s"//cull
"program defaultskin#VC%s\n"
"{\n"
"map $diffuse\n"
"%s" //blend
"%s" //rgbgen
"}\n"
"fte_basefactor %f %f %f %f\n"
"fte_specularfactor %f %f %f %f\n"
"fte_fullbrightfactor %f %f %f 1.0\n"
"}\n",
doubleSided?"cull disable\n":"",
alphaCutoffmodifier,
(alphaMode==1)?"":(alphaMode==2)?"blendfunc blend\n":"",
vertexcolours?"rgbgen vertex\nalphagen vertex\n":"",
JSON_GetFloat(pbrsg, "diffuseFactor.0", 1),
JSON_GetFloat(pbrsg, "diffuseFactor.1", 1),
JSON_GetFloat(pbrsg, "diffuseFactor.2", 1),
JSON_GetFloat(pbrsg, "diffuseFactor.3", 1),
JSON_GetFloat(pbrsg, "specularFactor.0", 1), //FIXME: divide by gl_specular
JSON_GetFloat(pbrsg, "specularFactor.1", 1),
JSON_GetFloat(pbrsg, "specularFactor.2", 1),
JSON_GetFloat(pbrsg, "shininessFactor", 1), //FIXME: divide by gl_specular_power
JSON_GetFloat(mat, "emissiveFactor.0", 0),
JSON_GetFloat(mat, "emissiveFactor.1", 0),
JSON_GetFloat(mat, "emissiveFactor.2", 0)
);
}
else if (pbrsg)
{ //if this extension was used, then we can use rgb gloss instead of metalness stuff.
ret->frame->texnums.base = GLTF_LoadTexture(gltf, JSON_GetInteger(pbrsg, "diffuseTexture.index", -1), 0);
ret->frame->texnums.specular = GLTF_LoadTexture(gltf, JSON_GetInteger(pbrsg, "specularGlossinessTexture.index", -1), 0);
Q_snprintf(shader, sizeof(shader),
"{\n"
"%s"//cull
"program defaultskin#SG#VC#NOOCCLUDE%s\n"
"{\n"
"map $diffuse\n"
"%s" //blend
"%s" //rgbgen
"}\n"
"fte_basefactor %f %f %f %f\n"
"fte_specularfactor %f %f %f %f\n"
"fte_fullbrightfactor %f %f %f 1.0\n"
"bemode rtlight rtlight_sg\n"
"}\n",
doubleSided?"cull disable\n":"",
alphaCutoffmodifier,
(alphaMode==1)?"":(alphaMode==2)?"blendfunc blend\n":"",
vertexcolours?"rgbgen vertex\nalphagen vertex\n":"",
JSON_GetFloat(pbrsg, "diffuseFactor.0", 1),
JSON_GetFloat(pbrsg, "diffuseFactor.1", 1),
JSON_GetFloat(pbrsg, "diffuseFactor.2", 1),
JSON_GetFloat(pbrsg, "diffuseFactor.3", 1),
JSON_GetFloat(pbrsg, "specularFactor.0", 1),
JSON_GetFloat(pbrsg, "specularFactor.1", 1),
JSON_GetFloat(pbrsg, "specularFactor.2", 1),
JSON_GetFloat(pbrsg, "glossinessFactor", 1)*32, //this is fucked.
JSON_GetFloat(mat, "emissiveFactor.0", 0),
JSON_GetFloat(mat, "emissiveFactor.1", 0),
JSON_GetFloat(mat, "emissiveFactor.2", 0)
);
}
else if (pbrmr)
{ //this is the standard lighting model for gltf2
int albedo = JSON_GetInteger(pbrmr, "baseColorTexture.index", -1); //.rgba
int mrt = JSON_GetInteger(pbrmr, "metallicRoughnessTexture.index", -1); //.r = unused, .g = roughness, .b = metalic, .a = unused
int occ = JSON_GetInteger(mat, "occlusionTexture.index", -1); //.r
//now work around potential lame exporters (yay dds?).
occ = JSON_GetInteger(mat, "extensions.MSFT_packing_occlusionRoughnessMetallic.occlusionRoughnessMetallicTexture.index", occ);
mrt = JSON_GetInteger(mat, "extensions.MSFT_packing_occlusionRoughnessMetallic.occlusionRoughnessMetallicTexture.index", mrt);
if (occ != mrt && occ != -1) //if its -1 then the mrt should have an unused channel set to 1. however, this isn't guarenteed...
{
occ = -1; //not supported. fixme: support some weird loadtexture channel merging stuff
if (gltf->warnlimit --> 0)
Con_Printf(CON_WARNING"%s: Separate occlusion and metallicRoughness textures are not supported\n", gltf->mod->name);
}
//note: extensions.MSFT_packing_normalRoughnessMetallic.normalRoughnessMetallicTexture.index gives rg=normalxy, b=roughness, .a=metalic
//(would still need an ao map, and probably wouldn't work well as bc3 either)
ret->frame->texnums.base = GLTF_LoadTexture(gltf, albedo, 0);
ret->frame->texnums.specular = GLTF_LoadTexture(gltf, mrt, IF_NOSRGB);
Q_snprintf(shader, sizeof(shader),
"{\n"
"%s"//cull
"program defaultskin#ORM#VC%s%s\n"
"{\n"
"map $diffuse\n"
"%s" //blend
"%s" //rgbgen
"}\n"
"fte_basefactor %f %f %f %f\n"
"fte_specularfactor %f %f %f 1.0\n"
"fte_fullbrightfactor %f %f %f 1.0\n"
"bemode rtlight rtlight_orm\n"
"}\n",
doubleSided?"cull disable\n":"",
(occ==-1)?"#NOOCCLUDE":"",
alphaCutoffmodifier,
(alphaMode==1)?"":(alphaMode==2)?"blendfunc blend\n":"",
vertexcolours?"rgbgen vertex\nalphagen vertex\n":"",
JSON_GetFloat(pbrmr, "baseColorFactor.0", 1),
JSON_GetFloat(pbrmr, "baseColorFactor.1", 1),
JSON_GetFloat(pbrmr, "baseColorFactor.2", 1),
JSON_GetFloat(pbrmr, "baseColorFactor.3", 1),
JSON_GetFloat(mat, "occlusionTexture.strength", 1),
JSON_GetFloat(pbrmr, "metallicFactor", 1),
JSON_GetFloat(pbrmr, "roughnessFactor", 1),
JSON_GetFloat(mat, "emissiveFactor.0", 0),
JSON_GetFloat(mat, "emissiveFactor.1", 0),
JSON_GetFloat(mat, "emissiveFactor.2", 0)
);
}
ret->frame->texnums.bump = GLTF_LoadTexture(gltf, JSON_GetInteger(mat, "normalTexture.index", -1), IF_NOSRGB|IF_TRYBUMP);
ret->frame->texnums.fullbright = GLTF_LoadTexture(gltf, JSON_GetInteger(mat, "emissiveTexture.index", -1), 0);
if (!ret->frame->texnums.base)
ret->frame->texnums.base = modfuncs->GetTexture("$whiteimage", NULL, IF_NOMIPMAP|IF_NOPICMIP|IF_NEAREST|IF_NOGAMMA, NULL, NULL, 0, 0, TF_INVALID);
ret->frame->defaultshader = memcpy(modfuncs->ZG_Malloc(&gltf->mod->memgroup, strlen(shader)+1), shader, strlen(shader)+1);
Q_strlcpy(ret->name, ret->frame->shadername, sizeof(ret->name));
return ret;
}
static qboolean GLTF_ProcessMesh(gltf_t *gltf, int meshidx, int basebone, double pmatrix[])
{
model_t *mod = gltf->mod;
json_t *mesh = JSON_FindIndexedChild(gltf->r, "meshes", meshidx);
json_t *prim;
json_t *meshname = JSON_FindChild(mesh, "name");
JSON_WarnIfChild(mesh, "weights", &gltf->warnlimit);
JSON_WarnIfChild(mesh, "extensions", &gltf->warnlimit);
// JSON_WarnIfChild(mesh, "extras", &gltf->warnlimit);
for(prim = JSON_FindIndexedChild(mesh, "primitives", 0); prim; prim = prim->sibling)
{
int mat = JSON_GetInteger(prim, "material", -1);
int mode = JSON_GetInteger(prim, "mode", 4);
json_t *attr = JSON_FindChild(prim, "attributes");
struct gltf_accessor tc_0, tc_1, norm, tang, vpos, col0, idx, sidx, swgt;
galiasinfo_t *surf;
size_t i, j;
prim->used = true;
if (mode != 4)
{
Con_Printf("Primitive mode %i not supported\n", mode);
continue;
}
JSON_WarnIfChild(prim, "targets", &gltf->warnlimit); //morph targets...
JSON_FindChild(prim, "extensions");
// JSON_WarnIfChild(prim, "extensions", &gltf->warnlimit);
// JSON_WarnIfChild(prim, "extras", &gltf->warnlimit);
GLTF_GetAccessor(gltf, JSON_GetInteger(attr, "TEXCOORD_0", -1), &tc_0); //float, ubyte, ushort
GLTF_GetAccessor(gltf, JSON_GetInteger(attr, "TEXCOORD_1", -1), &tc_1); //float, ubyte, ushort
GLTF_GetAccessor(gltf, JSON_GetInteger(attr, "NORMAL", -1), &norm); //float
GLTF_GetAccessor(gltf, JSON_GetInteger(attr, "TANGENT", -1), &tang); //float
GLTF_GetAccessor(gltf, JSON_GetInteger(attr, "POSITION", -1), &vpos); //float
GLTF_GetAccessor(gltf, JSON_GetInteger(attr, "COLOR_0", -1), &col0); //float, ubyte, ushort
GLTF_GetAccessor(gltf, JSON_GetInteger(prim, "indices", -1), &idx);
GLTF_GetAccessor(gltf, JSON_GetInteger(attr, "JOINTS_0", -1), &sidx); //ubyte, ushort
GLTF_GetAccessor(gltf, JSON_GetInteger(attr, "WEIGHTS_0", -1), &swgt); //float, ubyte, ushort
if (JSON_GetInteger(attr, "JOINTS_1", -1) != -1 || JSON_GetInteger(attr, "WEIGHTS_1", -1) != -1)
if (gltf->warnlimit --> 0)
Con_Printf(CON_WARNING "%s: only 4 bones supported per vert\n", gltf->mod->name); //in case a model tries supplying more. we ought to renormalise the weights in this case.
if (!vpos.count)
continue;
surf = modfuncs->ZG_Malloc(&mod->memgroup, sizeof(*surf));
surf->surfaceid = surf->contents = JSON_GetInteger(prim, "extras.fte.surfaceid", meshidx);
surf->contents = JSON_GetInteger(prim, "extras.fte.contents", FTECONTENTS_BODY);
surf->csurface.flags = JSON_GetInteger(prim, "extras.fte.surfaceflags", 0);
surf->geomset = JSON_GetInteger(prim, "extras.fte.geomset", ~0u);
surf->geomid = JSON_GetInteger(prim, "extras.fte.geomid", 0);
surf->mindist = JSON_GetInteger(prim, "extras.fte.mindist", 0);
surf->maxdist = JSON_GetInteger(prim, "extras.fte.maxdist", 0);
surf->shares_bones = gltf->numsurfaces;
surf->shares_verts = gltf->numsurfaces;
JSON_ReadBody(meshname, surf->surfacename, sizeof(surf->surfacename));
surf->numverts = vpos.count;
if (idx.data)
{
surf->numindexes = idx.count;
surf->ofs_indexes = modfuncs->ZG_Malloc(&mod->memgroup, sizeof(*surf->ofs_indexes) * idx.count);
if (idx.componentType == 5123)
{ //unsigned shorts
for (i = 0; i < idx.count; i++)
surf->ofs_indexes[i] = *(unsigned short *)((char*)idx.data + i*idx.bytestride);
}
else if (idx.componentType == 5121)
{ //unsigned bytes
for (i = 0; i < idx.count; i++)
surf->ofs_indexes[i] = *(unsigned char *)((char*)idx.data + i*idx.bytestride);
}
else if (idx.componentType == 5125)
{ //unsigned ints
for (i = 0; i < idx.count; i++)
surf->ofs_indexes[i] = *(unsigned int *)((char*)idx.data + i*idx.bytestride); //FIXME: bounds check.
}
else
continue;
}
else
{
surf->numindexes = surf->numverts;
surf->ofs_indexes = modfuncs->ZG_Malloc(&mod->memgroup, sizeof(*surf->ofs_indexes) * surf->numverts);
for (i = 0; i < surf->numverts; i++)
surf->ofs_indexes[i] = i;
}
//swap winding order. we cull wrongly.
for (i = 0; i < idx.count; i+=3)
{
index_t t = surf->ofs_indexes[i+0];
surf->ofs_indexes[i+0] = surf->ofs_indexes[i+2];
surf->ofs_indexes[i+2] = t;
}
surf->ofs_skel_xyz = GLTF_AccessorToDataF(gltf, surf->numverts, countof(surf->ofs_skel_xyz[0]), &vpos);
surf->ofs_skel_norm = GLTF_AccessorToDataF(gltf, surf->numverts, countof(surf->ofs_skel_norm[0]), &norm);
GLTF_AccessorToTangents(gltf, surf->ofs_skel_norm, &surf->ofs_skel_svect, &surf->ofs_skel_tvect, surf->numverts, &tang);
surf->ofs_st_array = GLTF_AccessorToDataF(gltf, surf->numverts, countof(surf->ofs_st_array[0]), &tc_0);
if (tc_1.data)
surf->ofs_lmst_array = GLTF_AccessorToDataF(gltf, surf->numverts, countof(surf->ofs_lmst_array[0]), &tc_1);
if (col0.data && col0.componentType == 5121) //UNSIGNED_BYTE
surf->ofs_rgbaub = GLTF_AccessorToDataUB(gltf, surf->numverts, countof(surf->ofs_rgbaub[0]), &col0);
else if (col0.data)
surf->ofs_rgbaf = GLTF_AccessorToDataF(gltf, surf->numverts, countof(surf->ofs_rgbaf[0]), &col0);
if (sidx.data && swgt.data)
{
surf->ofs_skel_idx = GLTF_AccessorToDataBone(gltf,surf->numverts, &sidx);
surf->ofs_skel_weight = GLTF_AccessorToDataF(gltf, surf->numverts, countof(surf->ofs_skel_weight[0]), &swgt);
for (i = 0; i < surf->numverts; i++)
{
float len = surf->ofs_skel_weight[i][0]+surf->ofs_skel_weight[i][1]+surf->ofs_skel_weight[i][2]+surf->ofs_skel_weight[i][3];
if (len)
Vector4Scale(surf->ofs_skel_weight[i], 1/len, surf->ofs_skel_weight[i]);
else
Vector4Set(surf->ofs_skel_weight[i], 0.5, 0.5, 0.5, 0.5);
}
}
else
{
surf->ofs_skel_idx = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(surf->ofs_skel_idx[0]) * surf->numverts);
surf->ofs_skel_weight = modfuncs->ZG_Malloc(&gltf->mod->memgroup, sizeof(surf->ofs_skel_weight[0]) * surf->numverts);
for (i = 0; i < surf->numverts; i++)
{
Vector4Set(surf->ofs_skel_idx[i], basebone, 0, 0, 0);
Vector4Set(surf->ofs_skel_weight[i], 1, 0, 0, 0);
}
}
// TransformArrayD(surf->ofs_skel_xyz, surf->numverts, pmatrix);
// TransformArrayA(surf->ofs_skel_norm, surf->numverts, pmatrix);
// TransformArrayA(surf->ofs_skel_svect, surf->numverts, pmatrix);
for (i = 0; i < surf->numverts; i++)
{
// VectorScale(surf->ofs_skel_xyz[i], 32, surf->ofs_skel_xyz[i]);
for (j = 0; j < 3; j++)
{
if (mod->maxs[j] < surf->ofs_skel_xyz[i][j])
mod->maxs[j] = surf->ofs_skel_xyz[i][j];
if (mod->mins[j] > surf->ofs_skel_xyz[i][j])
mod->mins[j] = surf->ofs_skel_xyz[i][j];
}
}
surf->numskins = 1;
surf->ofsskins = GLTF_LoadMaterial(gltf, mat, surf->ofs_rgbaub||surf->ofs_rgbaf);
if (!tang.data)
{
modfuncs->AccumulateTextureVectors(surf->ofs_skel_xyz, surf->ofs_st_array, surf->ofs_skel_norm, surf->ofs_skel_svect, surf->ofs_skel_tvect, surf->ofs_indexes, surf->numindexes, !norm.data);
modfuncs->NormaliseTextureVectors(surf->ofs_skel_norm, surf->ofs_skel_svect, surf->ofs_skel_tvect, surf->numverts, !norm.data);
}
gltf->numsurfaces++;
surf->nextsurf = mod->meshinfo;
mod->meshinfo = surf;
}
return true;
}
static void Matrix4D_Multiply(const double *a, const double *b, double *out)
{
out[0] = a[0] * b[0] + a[4] * b[1] + a[8] * b[2] + a[12] * b[3];
out[1] = a[1] * b[0] + a[5] * b[1] + a[9] * b[2] + a[13] * b[3];
out[2] = a[2] * b[0] + a[6] * b[1] + a[10] * b[2] + a[14] * b[3];
out[3] = a[3] * b[0] + a[7] * b[1] + a[11] * b[2] + a[15] * b[3];
out[4] = a[0] * b[4] + a[4] * b[5] + a[8] * b[6] + a[12] * b[7];
out[5] = a[1] * b[4] + a[5] * b[5] + a[9] * b[6] + a[13] * b[7];
out[6] = a[2] * b[4] + a[6] * b[5] + a[10] * b[6] + a[14] * b[7];
out[7] = a[3] * b[4] + a[7] * b[5] + a[11] * b[6] + a[15] * b[7];
out[8] = a[0] * b[8] + a[4] * b[9] + a[8] * b[10] + a[12] * b[11];
out[9] = a[1] * b[8] + a[5] * b[9] + a[9] * b[10] + a[13] * b[11];
out[10] = a[2] * b[8] + a[6] * b[9] + a[10] * b[10] + a[14] * b[11];
out[11] = a[3] * b[8] + a[7] * b[9] + a[11] * b[10] + a[15] * b[11];
out[12] = a[0] * b[12] + a[4] * b[13] + a[8] * b[14] + a[12] * b[15];
out[13] = a[1] * b[12] + a[5] * b[13] + a[9] * b[14] + a[13] * b[15];
out[14] = a[2] * b[12] + a[6] * b[13] + a[10] * b[14] + a[14] * b[15];
out[15] = a[3] * b[12] + a[7] * b[13] + a[11] * b[14] + a[15] * b[15];
}
static void GenMatrixPosQuat4ScaleDouble(const double pos[3], const double quat[4], const double scale[3], double result[16])
{
float xx, xy, xz, xw, yy, yz, yw, zz, zw;
float x2, y2, z2;
float s;
x2 = quat[0] + quat[0];
y2 = quat[1] + quat[1];
z2 = quat[2] + quat[2];
xx = quat[0] * x2; xy = quat[0] * y2; xz = quat[0] * z2;
yy = quat[1] * y2; yz = quat[1] * z2; zz = quat[2] * z2;
xw = quat[3] * x2; yw = quat[3] * y2; zw = quat[3] * z2;
s = scale[0];
result[0*4+0] = s*(1.0f - (yy + zz));
result[1*4+0] = s*(xy + zw);
result[2*4+0] = s*(xz - yw);
result[3*4+0] = 0;
s = scale[1];
result[0*4+1] = s*(xy - zw);
result[1*4+1] = s*(1.0f - (xx + zz));
result[2*4+1] = s*(yz + xw);
result[3*4+1] = 0;
s = scale[2];
result[0*4+2] = s*(xz + yw);
result[1*4+2] = s*(yz - xw);
result[2*4+2] = s*(1.0f - (xx + yy));
result[3*4+2] = 0;
result[0*4+3] = pos[0];
result[1*4+3] = pos[1];
result[2*4+3] = pos[2];
result[3*4+3] = 1;
}
static qboolean GLTF_ProcessNode(gltf_t *gltf, int nodeidx, double pmatrix[16], int parentidx, qboolean isjoint)
{
json_t *c;
json_t *node;
json_t *t;
json_t *skin;
int mesh;
int skinidx;
struct gltfbone_s *b;
if (nodeidx < 0 || nodeidx >= gltf->numbones)
{
Con_Printf(CON_WARNING"%s: Invalid node index %i\n", gltf->mod->name, nodeidx);
return false;
}
node = JSON_FindIndexedChild(gltf->r, "nodes", nodeidx);
if (!node)
{
Con_Printf(CON_WARNING"%s: Invalid node index %i\n", gltf->mod->name, nodeidx);
return false;
}
b = &gltf->bones[nodeidx];
b->parent = parentidx;
t = JSON_FindChild(node, "matrix");
if (t)
{
b->rel.rmatrix[0*4+0] = JSON_GetIndexedFloat(t, 0, 1.0);
b->rel.rmatrix[1*4+0] = JSON_GetIndexedFloat(t, 1, 0.0);
b->rel.rmatrix[2*4+0] = JSON_GetIndexedFloat(t, 2, 0.0);
b->rel.rmatrix[3*4+0] = JSON_GetIndexedFloat(t, 3, 0.0);
b->rel.rmatrix[0*4+1] = JSON_GetIndexedFloat(t, 4, 0.0);
b->rel.rmatrix[1*4+1] = JSON_GetIndexedFloat(t, 5, 1.0);
b->rel.rmatrix[2*4+1] = JSON_GetIndexedFloat(t, 6, 0.0);
b->rel.rmatrix[3*4+1] = JSON_GetIndexedFloat(t, 7, 0.0);
b->rel.rmatrix[0*4+2] = JSON_GetIndexedFloat(t, 8, 0.0);
b->rel.rmatrix[1*4+2] = JSON_GetIndexedFloat(t, 9, 0.0);
b->rel.rmatrix[2*4+2] = JSON_GetIndexedFloat(t, 10,1.0);
b->rel.rmatrix[3*4+2] = JSON_GetIndexedFloat(t, 11,0.0);
b->rel.rmatrix[0*4+3] = JSON_GetIndexedFloat(t, 12,0.0);
b->rel.rmatrix[1*4+3] = JSON_GetIndexedFloat(t, 13,0.0);
b->rel.rmatrix[2*4+3] = JSON_GetIndexedFloat(t, 14,0.0);
b->rel.rmatrix[3*4+3] = JSON_GetIndexedFloat(t, 15,1.0);
Vector4Set(b->rel.quat, 0,0,0,1);
VectorSet(b->rel.scale,1,1,1);
VectorSet(b->rel.trans,0,0,0);
}
else
{
double rot[4];
double scale[3];
double trans[3];
t = JSON_FindChild(node, "rotation");
rot[0] = JSON_GetIndexedFloat(t, 0, 0.0);
rot[1] = JSON_GetIndexedFloat(t, 1, 0.0);
rot[2] = JSON_GetIndexedFloat(t, 2, 0.0);
rot[3] = JSON_GetIndexedFloat(t, 3, 1.0);
t = JSON_FindChild(node, "scale");
scale[0] = JSON_GetIndexedFloat(t, 0, 1.0);
scale[1] = JSON_GetIndexedFloat(t, 1, 1.0);
scale[2] = JSON_GetIndexedFloat(t, 2, 1.0);
t = JSON_FindChild(node, "translation");
trans[0] = JSON_GetIndexedFloat(t, 0, 0.0);
trans[1] = JSON_GetIndexedFloat(t, 1, 0.0);
trans[2] = JSON_GetIndexedFloat(t, 2, 0.0);
Vector4Copy(rot, b->rel.quat);
VectorCopy(scale, b->rel.scale);
VectorCopy(trans, b->rel.trans);
//T * R * S
GenMatrixPosQuat4ScaleDouble(trans, rot, scale, b->rel.rmatrix);
/*
memset(mmatrix, 0, sizeof(mmatrix));
mmatrix[0] = 1;
mmatrix[5] = 1;
(void)rot,(void)scale;
mmatrix[10] = 1;
mmatrix[15] = 1;
mmatrix[3] = trans[0];
mmatrix[7] = trans[1];
mmatrix[11] = trans[2];
*/
}
Matrix4D_Multiply(b->rel.rmatrix, pmatrix, b->amatrix);
skinidx = JSON_GetInteger(node, "skin", -1);
if (skinidx >= 0)
{
// double identity[16];
int j;
json_t *joints;
struct gltf_accessor inverse;
float *inversef;
skin = JSON_FindIndexedChild(gltf->r, "skins", skinidx);
joints = JSON_FindChild(skin, "joints");
GLTF_GetAccessor(gltf, JSON_GetInteger(skin, "inverseBindMatrices", -1), &inverse);
inversef = inverse.data;
if (inverse.componentType != 5126/*FLOAT*/ || inverse.type != ((4<<8) | 4)/*mat4x4*/)
inverse.count = 0;
for (j = 0; j < MAX_BONES; j++, inversef+=inverse.bytestride/sizeof(float))
{
int b = JSON_GetIndexedInteger(joints, j, -1);
if (b < 0)
break;
gltf->bonemap[j] = b;
if (j < inverse.count)
{
gltf->bones[b].inverse[0] = inversef[0*4+0];
gltf->bones[b].inverse[1] = inversef[1*4+0];
gltf->bones[b].inverse[2] = inversef[2*4+0];
gltf->bones[b].inverse[3] = inversef[3*4+0];
gltf->bones[b].inverse[4] = inversef[0*4+1];
gltf->bones[b].inverse[5] = inversef[1*4+1];
gltf->bones[b].inverse[6] = inversef[2*4+1];
gltf->bones[b].inverse[7] = inversef[3*4+1];
gltf->bones[b].inverse[8] = inversef[0*4+2];
gltf->bones[b].inverse[9] = inversef[1*4+2];
gltf->bones[b].inverse[10]= inversef[2*4+2];
gltf->bones[b].inverse[11]= inversef[3*4+2];
gltf->bones[b].inverse[12]= inversef[0*4+3];
gltf->bones[b].inverse[13]= inversef[1*4+3];
gltf->bones[b].inverse[14]= inversef[2*4+3];
gltf->bones[b].inverse[15]= inversef[3*4+3];
}
else
{
gltf->bones[b].inverse[0] = 1;
gltf->bones[b].inverse[1] = 0;
gltf->bones[b].inverse[2] = 0;
gltf->bones[b].inverse[3] = 0;
gltf->bones[b].inverse[4] = 0;
gltf->bones[b].inverse[5] = 1;
gltf->bones[b].inverse[6] = 0;
gltf->bones[b].inverse[7] = 0;
gltf->bones[b].inverse[8] = 0;
gltf->bones[b].inverse[9] = 0;
gltf->bones[b].inverse[10]= 1;
gltf->bones[b].inverse[11]= 0;
gltf->bones[b].inverse[12]= 0;
gltf->bones[b].inverse[13]= 0;
gltf->bones[b].inverse[14]= 0;
gltf->bones[b].inverse[15]= 1;
}
}
// GLTF_ProcessNode(gltf, JSON_GetInteger(skin, "skeleton", -1), identity, nodeidx, true);
JSON_FlagAsUsed(node, "name");
}
mesh = JSON_GetInteger(node, "mesh", -1);
if (mesh >= 0)
GLTF_ProcessMesh(gltf, mesh, nodeidx, b->amatrix);
for(c = JSON_FindIndexedChild(node, "children", 0); c; c = c->sibling)
{
c->used = true;
GLTF_ProcessNode(gltf, JSON_GetInteger(c, NULL, -1), b->amatrix, nodeidx, isjoint);
}
b->camera = JSON_GetInteger(node, "camera", -1);
JSON_WarnIfChild(node, "weights", &gltf->warnlimit); //default value for morph weight animations
JSON_WarnIfChild(node, "extensions", &gltf->warnlimit);
// JSON_WarnIfChild(node, "extras", &gltf->warnlimit);
return true;
}
struct gltf_animsampler
{
struct gltf_accessor input;
struct gltf_accessor output;
};
static struct gltf_animsampler GLTF_AnimationSampler(gltf_t *gltf, json_t *samplers, int sampleridx, int elems)
{
struct gltf_animsampler r;
json_t *sampler = JSON_FindIndexedChild(samplers, NULL, sampleridx);
GLTF_GetAccessor(gltf, JSON_GetInteger(sampler, "input", -1), &r.input);
GLTF_GetAccessor(gltf, JSON_GetInteger(sampler, "output", -1), &r.output);
if (!r.input.data || !r.output.data || r.input.count != r.output.count)
memset(&r, 0, sizeof(r));
return r;
}
static float Anim_GetTime(struct gltf_accessor *in, int index)
{
//read the input sampler (to get timestamps)
switch(in->componentType)
{
case 5120: //BYTE
return max(-1, (*(signed char*)((qbyte*)in->data + in->bytestride*index)) / 127.0);
case 5121: //UNSIGNED_BYTE
return (*(unsigned char*)((qbyte*)in->data + in->bytestride*index)) / 255.0;
case 5122: //SHORT
return max(-1, (*(signed short*)((qbyte*)in->data + in->bytestride*index)) / 32767.0);
case 5123: //UNSIGNED_SHORT
return (*(unsigned short*)((qbyte*)in->data + in->bytestride*index)) / 65535.0;
case 5125: //UNSIGNED_INT
return (*(unsigned int*)((qbyte*)in->data + in->bytestride*index)) / (double)~0u;
case 5126: //FLOAT
return *(float*)((qbyte*)in->data + in->bytestride*index);
default:
Con_Printf("Unsupported input component type\n");
return 0;
}
}
static void Anim_GetVal(struct gltf_accessor *in, int index, float *result, int elems)
{
//read the input sampler (to get timestamps)
switch(in->componentType)
{
case 5120: //BYTE
while (elems --> 0)
result[elems] = max(-1, ((signed char*)((qbyte*)in->data + in->bytestride*index))[elems] / 127.0);
break;
case 5121: //UNSIGNED_BYTE
while (elems --> 0)
result[elems] = ((unsigned char*)((qbyte*)in->data + in->bytestride*index))[elems] / 255.0;
break;
case 5122: //SHORT
while (elems --> 0)
result[elems] = max(-1, ((signed short*)((qbyte*)in->data + in->bytestride*index))[elems] / 32767.0);
break;
case 5123: //UNSIGNED_SHORT
while (elems --> 0)
result[elems] = ((unsigned short*)((qbyte*)in->data + in->bytestride*index))[elems] / 65535.0;
break;
case 5125: //UNSIGNED_INT
while (elems --> 0)
result[elems] = ((unsigned int*)((qbyte*)in->data + in->bytestride*index))[elems] / (double)~0u;
break;
case 5126: //FLOAT
while (elems --> 0)
result[elems] = ((float*)((qbyte*)in->data + in->bytestride*index))[elems];
break;
default:
Con_Printf("Unsupported output component type\n");
break;
}
}
static void LerpAnimData(gltf_t *gltf, struct gltf_animsampler *samp, float time, float *result, int elems)
{
float t1, t2;
float w1, w2;
float v1[4], v2[4];
int f1 = 0, f2, c;
struct gltf_accessor *in = &samp->input;
struct gltf_accessor *out = &samp->output;
t1 = t2 = Anim_GetTime(in, f1);
for (f2 = 1; f2 < in->count; f2++)
{
t2 = Anim_GetTime(in, f2);
if (t2 > time)
break; //now have before and after
t1 = t2;
f1 = f2;
}
if (time <= t1)
{ //if before the first time, clamp it.
w1 = 1;
w2 = 0;
}
else if (time >= t2)
{ //if after tha last frame we could find, clamp it to the last.
w1 = 0;
w2 = 1;
}
else
{ //assume linear
w2 = (time-t1)/(t2-t1);
// if (1) //step it. it'll still get lerped though. :(
// w2 = (w2>0.5)?1:0;
w1 = 1-w2;
}
if (w1 >= 1)
Anim_GetVal(out, f1, result, elems);
else if (w2 >= 1)
Anim_GetVal(out, f2, result, elems);
else
{
Anim_GetVal(out, f1, v1, elems);
Anim_GetVal(out, f2, v2, elems);
for (c = 0; c < elems; c++)
result[c] = v1[c]*w1 + w2*v2[c];
}
}
static void GLTF_RemapBone(gltf_t *gltf, int *nextidx, int b)
{ //potentially needs to walk to the root before the child. recursion sucks.
if (gltf->bonemap[b] >= 0)
return; //already got remapped
GLTF_RemapBone(gltf, nextidx, gltf->bones[b].parent);
gltf->bonemap[b] = (*nextidx)++;
}
static void GLTF_RewriteBoneTree(gltf_t *gltf)
{
galiasinfo_t *surf;
int j, n;
struct gltfbone_s *tmpbones;
for (j = 0; j < gltf->numbones; j++)
{
if (gltf->bones[j].parent >= j)
break;
}
if (j == gltf->numbones)
{
for (j = 0; j < gltf->numbones; j++)
gltf->bonemap[j] = j;
return; //all are ordered okay
}
for (j = 0; j < gltf->numbones; j++)
gltf->bonemap[j] = -1;
for ( ; j < MAX_BONES; j++)
gltf->bonemap[j] = 0;
n = 0;
for (j = 0; j < gltf->numbones; j++)
GLTF_RemapBone(gltf, &n, j);
tmpbones = malloc(sizeof(*tmpbones)*gltf->numbones);
memcpy(tmpbones, gltf->bones, sizeof(*tmpbones)*gltf->numbones);
for (j = 0; j < gltf->numbones; j++)
gltf->bones[gltf->bonemap[j]] = tmpbones[j];
for (j = 0; j < gltf->numbones; j++)
if (gltf->bones[j].parent >= 0)
gltf->bones[j].parent = gltf->bonemap[gltf->bones[j].parent];
for(surf = gltf->mod->meshinfo; surf; surf = surf->nextsurf)
{
for (j = 0; j < surf->numverts; j++)
for (n = 0; n < countof(surf->ofs_skel_idx[j]); n++)
surf->ofs_skel_idx[j][n] = gltf->bonemap[surf->ofs_skel_idx[j][n]];
}
}
//okay, so gltf is some weird scene thing.
//mostly there should be some default scene, so we'll just use that.
//we do NOT supported nested nodes right now...
static qboolean GLTF_LoadModel(struct model_s *mod, char *json, size_t jsonsize, void *buffer, size_t buffersize)
{
static struct
{
const char *name;
qboolean supported; //unsupported extensions don't really need to be listed, but they do prevent warnings from unkown-but-used extensions
} extensions[] =
{
{"KHR_materials_pbrSpecularGlossiness", true},
//draft {"KHR_materials_cmnBlinnPhong", true},
{"KHR_materials_unlit", true},
{"KHR_texture_transform", false},
{"KHR_draco_mesh_compression", false},
{"MSFT_texture_dds", true},
{"MSFT_packing_occlusionRoughnessMetallic", true},
};
gltf_t gltf;
int pos=0, j, k;
json_t *scene, *n, *anim;
double rootmatrix[16];
double gltfver;
galiasinfo_t *surf;
galiasbone_t *bone;
galiasanimation_t *framegroups = NULL;
unsigned int numframegroups = 0;
float *baseframe;
memset(&gltf, 0, sizeof(gltf));
gltf.bonemap = malloc(sizeof(*gltf.bonemap)*MAX_BONES);
gltf.bones = malloc(sizeof(*gltf.bones)*MAX_BONES);
memset(gltf.bones, 0, sizeof(*gltf.bones)*MAX_BONES);
gltf.r = JSON_Parse(NULL, mod->name, NULL, json, &pos, jsonsize);
gltf.mod = mod;
gltf.buffers[0].data = buffer;
gltf.buffers[0].length = buffersize;
gltf.warnlimit = 5;
Added pm_pground cvar for compat with mvdsv/ezquake. Do not use it with NQ mods however, as the QC will interfere with the onground state (QW mods are okay). Added Z_EXT_PF_ONGROUND + Z_EXT_PF_SOLID for compat (not enabled serverside due to conflicts with pext - just a define away). Fixed bug with loading screens switching sizes part way through loading. Added hexen2 rain effect. Fix hexen2 model texture alphas not working. Fix potential linux crash from excessively long stdin lines. Added cl_rollalpha cvar. Fixed quirk where the player would slide along the base of steep walls/slopes. Tweaked PM_NudgePosition to be more precise, giving more reliable prediction. Fixed fread qc builtin. Tweaked random() builtin to bias slightly away from 0, so that nextthink=random()*foo; will never cause statue-monsters. Check for GL_WEBGL_depth_texture instead of just GL_OES_depth_texture, to fix compressedTex2d errors in firefox. Second attempt at blocking invariant keyword with mesa. Use xrandr for gamma where possible. This prevents reading stale XF86 gamma ramps and restoring those invalid ramps when quitting. Try to grab mouse pointers slightly faster in x11. Don't call XIFreeDeviceInfo if XIQueryDevice returned NULL. Document parm_string and startspot qc globals. Fix possible infinite loop from physics frames. QTV: stripped most of the old plugin code (because really, who has a browser that still supports either ActiveX or NPAPI). Fixed up emscripten port references. QTV: fix bug with protocol extensions not being reported to viewers. QTV: use binary websockets instead of text. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5419 fc73d0e0-1445-4013-8a0c-d673dee63da5
2019-03-01 22:39:30 +00:00
//asset.version must exist, supposedly. so default to something b0rked
gltfver = JSON_GetFloat(gltf.r, "asset.minVersion", 0.0);
if (gltfver != 2.0)
gltfver = JSON_GetFloat(gltf.r, "asset.version", 0.0);
if (gltfver == 2.0)
{
JSON_FlagAsUsed(gltf.r, "asset.copyright");
JSON_FlagAsUsed(gltf.r, "asset.generator");
JSON_WarnIfChild(gltf.r, "asset.minVersion", &gltf.warnlimit);
JSON_WarnIfChild(gltf.r, "asset.extensions", &gltf.warnlimit);
for(n = JSON_FindIndexedChild(gltf.r, "extensionsRequired", 0); n; n = n->sibling)
{
char extname[256];
JSON_ReadBody(n, extname, sizeof(extname));
for (j = 0; j < countof(extensions); j++)
{
if (!strcmp(extname, extensions[j].name))
break;
}
if (j==countof(extensions) || !extensions[j].supported)
Con_Printf(CON_ERROR "%s: Required gltf2 extension \"%s\" not supported\n", mod->name, extname);
goto abort;
}
for(n = JSON_FindIndexedChild(gltf.r, "extensionsUsed", 0); n; n = n->sibling)
{ //must be a superset of the above.
char extname[256];
JSON_ReadBody(n, extname, sizeof(extname));
for (j = 0; j < countof(extensions); j++)
{
if (!strcmp(extname, extensions[j].name))
break;
}
if (j==countof(extensions) || !extensions[j].supported)
Con_Printf(CON_WARNING "%s: gltf2 extension \"%s\" not known\n", mod->name, extname);
}
VectorClear(mod->maxs);
VectorClear(mod->mins);
//we don't really care about cameras.
JSON_FlagAsUsed(gltf.r, "cameras");
scene = JSON_FindIndexedChild(gltf.r, "scenes", JSON_GetInteger(gltf.r, "scene", 0));
memset(&rootmatrix, 0, sizeof(rootmatrix));
#if 1 //transform from gltf to quake. mostly only needed for the base pose.
rootmatrix[2] = rootmatrix[4] = rootmatrix[9] = GLTFSCALE; rootmatrix[15] = 1;
#else
rootmatrix[0] = rootmatrix[5] = rootmatrix[10] = 1; rootmatrix[15] = 1;
#endif
for (j = 0; ; j++)
{
n = JSON_FindIndexedChild(gltf.r, "nodes", j);
if (!n)
break;
if (j == MAX_BONES)
{
Con_Printf(CON_WARNING"%s: too many nodes (max %i)\n", mod->name, MAX_BONES);
break;
}
if (!JSON_ReadBody(JSON_FindChild(n, "name"), gltf.bones[j].name, sizeof(gltf.bones[j].name)))
{
if (n)
JSON_GetPath(n, true, gltf.bones[j].name, sizeof(gltf.bones[j].name));
else
Q_snprintf(gltf.bones[j].name, sizeof(gltf.bones[j].name), "bone%i", j);
}
gltf.bones[j].camera = -1;
gltf.bones[j].parent = -1;
gltf.bones[j].amatrix[0] = gltf.bones[j].amatrix[5] = gltf.bones[j].amatrix[10] = gltf.bones[j].amatrix[15] = 1;
gltf.bones[j].inverse[0] = gltf.bones[j].inverse[5] = gltf.bones[j].inverse[10] = gltf.bones[j].inverse[15] = 1;
gltf.bones[j].rel.rmatrix[0] = gltf.bones[j].rel.rmatrix[5] = gltf.bones[j].rel.rmatrix[10] = gltf.bones[j].rel.rmatrix[15] = 1;
}
gltf.numbones = j;
JSON_FlagAsUsed(scene, "name");
JSON_WarnIfChild(scene, "extensions", &gltf.warnlimit);
// JSON_WarnIfChild(scene, "extras");
for (j = 0; ; j++)
{
n = JSON_FindIndexedChild(scene, "nodes", j);
if (!n)
break;
n->used = true;
// if (!
GLTF_ProcessNode(&gltf, JSON_GetInteger(n, NULL, -1), rootmatrix, -1, false);
// break;
}
GLTF_RewriteBoneTree(&gltf);
bone = modfuncs->ZG_Malloc(&mod->memgroup, sizeof(*bone)*gltf.numbones);
baseframe = modfuncs->ZG_Malloc(&mod->memgroup, sizeof(float)*12*gltf.numbones);
for (j = 0; j < gltf.numbones; j++)
{
Q_strlcpy(bone[j].name, gltf.bones[j].name, sizeof(bone[j].name));
bone[j].parent = gltf.bones[j].parent;
if (gltf.bones[j].camera >= 0 && !mod->camerabone)
mod->camerabone = j+1;
for(k = 0; k < 12; k++)
{
baseframe[j*12+k] = gltf.bones[j].amatrix[k];
bone[j].inverse[k] = gltf.bones[j].inverse[k];
}
}
for(anim = JSON_FindIndexedChild(gltf.r, "animations", 0); anim; anim = anim->sibling)
numframegroups++;
if (numframegroups)
{
struct
{
struct gltf_animsampler rot,scale,trans;
} *b = malloc(sizeof(*b)*gltf.numbones);
framegroups = modfuncs->ZG_Malloc(&mod->memgroup, sizeof(*framegroups)*numframegroups);
for (k = 0; k < numframegroups; k++)
{
galiasanimation_t *fg = &framegroups[k];
json_t *anim = JSON_FindIndexedChild(gltf.r, "animations", k);
json_t *chan;
json_t *samps = JSON_FindChild(anim, "samplers");
int f, l;
float maxtime = 0;
memset(b, 0, sizeof(*b)*gltf.numbones);
if (!JSON_ReadBody(JSON_FindChild(anim, "name"), fg->name, sizeof(fg->name)))
{
if (anim)
JSON_GetPath(anim, true, fg->name, sizeof(fg->name));
else
Q_snprintf(fg->name, sizeof(fg->name), "anim%i", k);
}
fg->loop = true;
fg->skeltype = SKEL_RELATIVE;
for(chan = JSON_FindIndexedChild(anim, "channels", 0); chan; chan = chan->sibling)
{
struct gltf_animsampler s;
json_t *targ = JSON_FindChild(chan, "target");
int sampler = JSON_GetInteger(chan, "sampler", -1);
int bone = JSON_GetInteger(targ, "node", -2);
json_t *path = JSON_FindChild(targ, "path");
if (bone == -2)
continue; //'When node isn't defined, channel should be ignored'
if (bone < 0 || bone >= gltf.numbones)
{
if (gltf.warnlimit --> 0)
Con_Printf("%s: invalid node index %i\n", mod->name, bone);
continue; //error...
}
bone = gltf.bonemap[bone];
s = GLTF_AnimationSampler(&gltf, samps, sampler, 4);
maxtime = max(maxtime, s.input.maxs[0]);
if (JSON_Equals(path, NULL, "rotation"))
b[bone].rot = s;
else if (JSON_Equals(path, NULL, "scale"))
b[bone].scale = s;
else if (JSON_Equals(path, NULL, "translation"))
b[bone].trans = s;
else if (gltf.warnlimit --> 0)
{ //these are unsupported
if (JSON_Equals(path, NULL, "weights")) //morph weights
Con_Printf(CON_WARNING"%s: morph animations are not supported\n", mod->name);
else
Con_Printf("%s: undocumented animation type\n", mod->name);
}
}
Added pm_pground cvar for compat with mvdsv/ezquake. Do not use it with NQ mods however, as the QC will interfere with the onground state (QW mods are okay). Added Z_EXT_PF_ONGROUND + Z_EXT_PF_SOLID for compat (not enabled serverside due to conflicts with pext - just a define away). Fixed bug with loading screens switching sizes part way through loading. Added hexen2 rain effect. Fix hexen2 model texture alphas not working. Fix potential linux crash from excessively long stdin lines. Added cl_rollalpha cvar. Fixed quirk where the player would slide along the base of steep walls/slopes. Tweaked PM_NudgePosition to be more precise, giving more reliable prediction. Fixed fread qc builtin. Tweaked random() builtin to bias slightly away from 0, so that nextthink=random()*foo; will never cause statue-monsters. Check for GL_WEBGL_depth_texture instead of just GL_OES_depth_texture, to fix compressedTex2d errors in firefox. Second attempt at blocking invariant keyword with mesa. Use xrandr for gamma where possible. This prevents reading stale XF86 gamma ramps and restoring those invalid ramps when quitting. Try to grab mouse pointers slightly faster in x11. Don't call XIFreeDeviceInfo if XIQueryDevice returned NULL. Document parm_string and startspot qc globals. Fix possible infinite loop from physics frames. QTV: stripped most of the old plugin code (because really, who has a browser that still supports either ActiveX or NPAPI). Fixed up emscripten port references. QTV: fix bug with protocol extensions not being reported to viewers. QTV: use binary websockets instead of text. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5419 fc73d0e0-1445-4013-8a0c-d673dee63da5
2019-03-01 22:39:30 +00:00
//TODO: make a guess at the framerate according to sampler intervals
fg->rate = 60;
fg->numposes = max(1, maxtime*fg->rate);
if (maxtime)
fg->rate = fg->numposes/maxtime; //fix up the rate so we hit the exact end of the animation (so it doesn't have to be quite so exact).
fg->skeltype = SKEL_RELATIVE;
fg->boneofs = modfuncs->ZG_Malloc(&mod->memgroup, sizeof(*fg->boneofs)*12*gltf.numbones*fg->numposes);
for (f = 0; f < fg->numposes; f++)
{
float *bonematrix = &fg->boneofs[f*gltf.numbones*12];
float time = f/fg->rate;
for (j = 0; j < gltf.numbones; j++, bonematrix+=12)
{
float scale[3];
float rot[4];
float trans[3];
//eww, weird inheritance crap.
if (b[j].rot.input.data || b[j].scale.input.data || b[j].trans.input.data)
{
VectorCopy(gltf.bones[j].rel.scale, scale);
Vector4Copy(gltf.bones[j].rel.quat, rot);
VectorCopy(gltf.bones[j].rel.trans, trans);
if (b[j].rot.input.data)
LerpAnimData(&gltf, &b[j].rot, time, rot, 4);
if (b[j].scale.input.data)
LerpAnimData(&gltf, &b[j].scale, time, scale, 3);
if (b[j].trans.input.data)
LerpAnimData(&gltf, &b[j].trans, time, trans, 3);
//figure out the bone matrix...
modfuncs->GenMatrixPosQuat4Scale(trans, rot, scale, bonematrix);
}
else
{ //nothing animated, use what we calculated earlier.
for (l = 0; l < 12; l++)
bonematrix[l] = gltf.bones[j].rel.rmatrix[l];
}
if (gltf.bones[j].parent < 0)
{ //rotate any root bones from gltf to quake's orientation.
float fnar[12];
static float toquake[12]={0,0,GLTFSCALE,0,GLTFSCALE,0,0,0,0,GLTFSCALE,0,0};
memcpy(fnar, bonematrix, sizeof(fnar));
modfuncs->ConcatTransforms((void*)toquake, (void*)fnar, (void*)bonematrix);
}
}
}
}
free(b);
}
for(surf = mod->meshinfo; surf; surf = surf->nextsurf)
{
surf->shares_bones = 0;
surf->numbones = gltf.numbones;
surf->ofsbones = bone;
surf->baseframeofs = baseframe;
surf->ofsanimations = framegroups;
surf->numanimations = numframegroups;
surf->contents = FTECONTENTS_BODY;
surf->csurface.flags = 0;
surf->geomset = ~0; //invalid set = always visible. FIXME: set this according to scene numbers?
surf->geomid = 0;
}
VectorScale(mod->mins, GLTFSCALE, mod->mins);
VectorScale(mod->maxs, GLTFSCALE, mod->maxs);
if (!mod->meshinfo)
Con_Printf("%s: Doesn't contain any meshes...\n", mod->name);
JSON_WarnUnused(gltf.r, &gltf.warnlimit);
}
else
Con_Printf("%s: unsupported gltf version (%.2f)\n", mod->name, gltfver);
abort:
JSON_Destroy(gltf.r);
free(gltf.bones);
free(gltf.bonemap);
mod->type = mod_alias;
return !!mod->meshinfo;
}
qboolean QDECL Mod_LoadGLTFModel (struct model_s *mod, void *buffer, size_t fsize)
{
//just straight json.
return GLTF_LoadModel(mod, buffer, fsize, NULL, 0);
}
//glb files are some binary header, a lump with json data, and optionally a lump with binary data
qboolean QDECL Mod_LoadGLBModel (struct model_s *mod, void *buffer, size_t fsize)
{
unsigned char *header = buffer;
unsigned int magic = header[0]|(header[1]<<8)|(header[2]<<16)|(header[3]<<24);
unsigned int version = header[4]|(header[5]<<8)|(header[6]<<16)|(header[7]<<24);
unsigned int length = header[8]|(header[9]<<8)|(header[10]<<16)|(header[11]<<24);
unsigned int jsonlen = header[12]|(header[13]<<8)|(header[14]<<16)|(header[15]<<24);
unsigned int jsontype = header[16]|(header[17]<<8)|(header[18]<<16)|(header[19]<<24);
char *json = (char*)(header+20);
unsigned int binlen = header[20+jsonlen]|(header[21+jsonlen]<<8)|(header[22+jsonlen]<<16)|(header[23+jsonlen]<<24);
unsigned int bintype = header[24+jsonlen]|(header[25+jsonlen]<<8)|(header[26+jsonlen]<<16)|(header[27+jsonlen]<<24);
unsigned char *bin = header+28+jsonlen;
if (fsize < 28)
return false;
if (magic != (('F'<<24)+('T'<<16)+('l'<<8)+'g'))
return false;
if (version != 2)
return false;
if (jsontype != 0x4E4F534A) //'JSON'
return false;
if (length != 28+jsonlen+binlen)
return false;
if (bintype != 0x004E4942) //'BIN\0'
return false;
return GLTF_LoadModel(mod, json, jsonlen, bin, binlen);
}
#endif