void
R_AliasDrawModel (alight_t *plighting)
{
int size;
finalvert_t *finalverts;
r_amodels_drawn++;
if (!(paliashdr = currententity->model->aliashdr))
paliashdr = Cache_Get (¤tentity->model->cache);
pmdl = (mdl_t *) ((byte *) paliashdr + paliashdr->model);
size = (CACHE_SIZE - 1)
+ sizeof (finalvert_t) * (pmdl->numverts + 1)
+ sizeof (auxvert_t) * pmdl->numverts;
finalverts = (finalvert_t *) Hunk_TempAlloc (size);
if (!finalverts)
Sys_Error ("R_AliasDrawModel: out of memory");
// cache align
pfinalverts = (finalvert_t *)
(((intptr_t) &finalverts[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
pauxverts = (auxvert_t *) &pfinalverts[pmdl->numverts + 1];
R_AliasSetupSkin ();
R_AliasSetUpTransform (currententity->trivial_accept);
R_AliasSetupLighting (plighting);
R_AliasSetupFrame ();
r_affinetridesc.drawtype = (currententity->trivial_accept == 3) &&
r_recursiveaffinetriangles;
if (!acolormap)
acolormap = vid.colormap8;
if (r_affinetridesc.drawtype) {
D_PolysetUpdateTables (); // FIXME: precalc...
} else {
#ifdef USE_INTEL_ASM
D_Aff8Patch (acolormap);
#endif
}
if (currententity != vr_data.view_model)
ziscale = (float) 0x8000 *(float) 0x10000;
else
ziscale = (float) 0x8000 *(float) 0x10000 *3.0;
if (currententity->trivial_accept && pmdl->ident != HEADER_MDL16)
R_AliasPrepareUnclippedPoints ();
else
R_AliasPreparePoints ();
if (!currententity->model->aliashdr)
Cache_Release (¤tentity->model->cache);
}
void
sw32_R_AliasDrawModel (alight_t *plighting)
{
int size;
finalvert_t *finalverts;
sw32_r_amodels_drawn++;
if (!(paliashdr = currententity->model->aliashdr))
paliashdr = Cache_Get (¤tentity->model->cache);
pmdl = (mdl_t *) ((byte *) paliashdr + paliashdr->model);
size = (CACHE_SIZE - 1)
+ sizeof (finalvert_t) * (pmdl->numverts + 1)
+ sizeof (auxvert_t) * pmdl->numverts;
finalverts = (finalvert_t *) Hunk_TempAlloc (size);
if (!finalverts)
Sys_Error ("R_AliasDrawModel: out of memory");
// cache align
pfinalverts = (finalvert_t *)
(((intptr_t) &finalverts[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
sw32_pauxverts = (auxvert_t *) &pfinalverts[pmdl->numverts + 1];
R_AliasSetupSkin ();
sw32_R_AliasSetUpTransform (currententity->trivial_accept);
R_AliasSetupLighting (plighting);
R_AliasSetupFrame ();
if (!sw32_acolormap)
sw32_acolormap = vid.colormap8;
if (sw32_acolormap == &vid.colormap8 && sw32_r_pixbytes != 1)
{
if (sw32_r_pixbytes == 2)
sw32_acolormap = vid.colormap16;
else if (sw32_r_pixbytes == 4)
sw32_acolormap = vid.colormap32;
else
Sys_Error("R_AliasDrawmodel: unsupported r_pixbytes %i",
sw32_r_pixbytes);
}
if (currententity != vr_data.view_model)
sw32_ziscale = (float) 0x8000 *(float) 0x10000;
else
sw32_ziscale = (float) 0x8000 *(float) 0x10000 *3.0;
if (currententity->trivial_accept)
R_AliasPrepareUnclippedPoints ();
else
R_AliasPreparePoints ();
if (!currententity->model->aliashdr)
Cache_Release (¤tentity->model->cache);
}
static void fill_cache (Cache* cache, bool create, int a, int b)
{
int i;
for (i = a; i < b; i++) {
char buffer [20];
sprintf (buffer, "[%d]", i);
int** iptr = (int**) Cache_Get (cache, buffer);
assert (iptr != NULL);
if (create) {
assert (*iptr == NULL);
*iptr = talloc (cache, int);
**iptr = i;
} else {
assert (*iptr != NULL);
assert (**iptr == i);
}
}
qboolean
sw32_R_AliasCheckBBox (void)
{
int i, flags, frame, numv;
aliashdr_t *pahdr;
float zi, basepts[8][3], v0, v1, frac;
finalvert_t *pv0, *pv1, viewpts[16];
auxvert_t *pa0, *pa1, viewaux[16];
maliasframedesc_t *pframedesc;
qboolean zclipped, zfullyclipped;
unsigned int anyclip, allclip;
int minz;
// expand, rotate, and translate points into worldspace
currententity->trivial_accept = 0;
pmodel = currententity->model;
if (!(pahdr = pmodel->aliashdr))
pahdr = Cache_Get (&pmodel->cache);
pmdl = (mdl_t *) ((byte *) pahdr + pahdr->model);
sw32_R_AliasSetUpTransform (0);
// construct the base bounding box for this frame
frame = currententity->frame;
// TODO: don't repeat this check when drawing?
if ((frame >= pmdl->numframes) || (frame < 0)) {
Sys_MaskPrintf (SYS_DEV, "No such frame %d %s\n", frame, pmodel->name);
frame = 0;
}
pframedesc = &pahdr->frames[frame];
// x worldspace coordinates
basepts[0][0] = basepts[1][0] = basepts[2][0] = basepts[3][0] =
(float) pframedesc->bboxmin.v[0];
basepts[4][0] = basepts[5][0] = basepts[6][0] = basepts[7][0] =
(float) pframedesc->bboxmax.v[0];
// y worldspace coordinates
basepts[0][1] = basepts[3][1] = basepts[5][1] = basepts[6][1] =
(float) pframedesc->bboxmin.v[1];
basepts[1][1] = basepts[2][1] = basepts[4][1] = basepts[7][1] =
(float) pframedesc->bboxmax.v[1];
// z worldspace coordinates
basepts[0][2] = basepts[1][2] = basepts[4][2] = basepts[5][2] =
(float) pframedesc->bboxmin.v[2];
basepts[2][2] = basepts[3][2] = basepts[6][2] = basepts[7][2] =
(float) pframedesc->bboxmax.v[2];
zclipped = false;
zfullyclipped = true;
minz = 9999;
for (i = 0; i < 8; i++) {
sw32_R_AliasTransformVector (&basepts[i][0], &viewaux[i].fv[0]);
if (viewaux[i].fv[2] < ALIAS_Z_CLIP_PLANE) {
// we must clip points that are closer than the near clip plane
viewpts[i].flags = ALIAS_Z_CLIP;
zclipped = true;
} else {
if (viewaux[i].fv[2] < minz)
minz = viewaux[i].fv[2];
viewpts[i].flags = 0;
zfullyclipped = false;
}
}
if (zfullyclipped) {
if (!pmodel->aliashdr)
Cache_Release (&pmodel->cache);
return false; // everything was near-z-clipped
}
numv = 8;
if (zclipped) {
// organize points by edges, use edges to get new points (possible
// trivial reject)
for (i = 0; i < 12; i++) {
// edge endpoints
pv0 = &viewpts[aedges[i].index0];
pv1 = &viewpts[aedges[i].index1];
pa0 = &viewaux[aedges[i].index0];
pa1 = &viewaux[aedges[i].index1];
// if one end is clipped and the other isn't, make a new point
if (pv0->flags ^ pv1->flags) {
frac = (ALIAS_Z_CLIP_PLANE - pa0->fv[2]) /
(pa1->fv[2] - pa0->fv[2]);
viewaux[numv].fv[0] = pa0->fv[0] +
(pa1->fv[0] - pa0->fv[0]) * frac;
viewaux[numv].fv[1] = pa0->fv[1] +
(pa1->fv[1] - pa0->fv[1]) * frac;
viewaux[numv].fv[2] = ALIAS_Z_CLIP_PLANE;
viewpts[numv].flags = 0;
numv++;
}
}
}
// project the vertices that remain after clipping
anyclip = 0;
allclip = ALIAS_XY_CLIP_MASK;
// TODO: probably should do this loop in ASM, especially if we use floats
for (i = 0; i < numv; i++) {
// we don't need to bother with vertices that were z-clipped
if (viewpts[i].flags & ALIAS_Z_CLIP)
continue;
zi = 1.0 / viewaux[i].fv[2];
// FIXME: do with chop mode in ASM, or convert to float
v0 = (viewaux[i].fv[0] * sw32_xscale * zi) + sw32_xcenter;
v1 = (viewaux[i].fv[1] * sw32_yscale * zi) + sw32_ycenter;
flags = 0;
if (v0 < r_refdef.fvrectx)
flags |= ALIAS_LEFT_CLIP;
if (v1 < r_refdef.fvrecty)
flags |= ALIAS_TOP_CLIP;
if (v0 > r_refdef.fvrectright)
flags |= ALIAS_RIGHT_CLIP;
if (v1 > r_refdef.fvrectbottom)
flags |= ALIAS_BOTTOM_CLIP;
anyclip |= flags;
allclip &= flags;
}
if (allclip) {
if (!pmodel->aliashdr)
Cache_Release (&pmodel->cache);
return false; // trivial reject off one side
}
currententity->trivial_accept = !anyclip & !zclipped;
if (currententity->trivial_accept) {
if (minz > (sw32_r_aliastransition + (pmdl->size * sw32_r_resfudge))) {
currententity->trivial_accept |= 2;
}
}
if (!pmodel->aliashdr)
Cache_Release (&pmodel->cache);
return true;
}
/******************************************************************************
* BrowseOrSearchWithCache
*****************************************************************************/
static const ContentDir_BrowseResult*
BrowseOrSearchWithCache (ContentDir* cds, void* result_context,
const char* objectId, const char* const criteria)
{
if (cds == NULL || objectId == NULL || criteria == NULL)
return NULL; // ---------->
BrowseResult* br = talloc (result_context, BrowseResult);
if (br == NULL)
return NULL; // ---------->
*br = (BrowseResult) { .cds = cds };
if (cds->cache == NULL) {
/*
* No cache
*/
br->children = BrowseOrSearchAll (cds, br, objectId, criteria);
} else {
/*
* Lookup and/or update cache
*/
ithread_mutex_lock (&cds->cache_mutex);
char key_buffer [strlen(objectId) + strlen(criteria) + 2 ];
const char* key;
if (criteria == CRITERIA_BROWSE_CHILDREN) {
key = objectId;
} else {
// criteria == "BrowseMetadata" or Search criteria
sprintf (key_buffer, "%s\t%s", objectId, criteria);
key = key_buffer;
}
Children** cp = (Children**) Cache_Get (cds->cache, key);
if (cp) {
if (*cp) {
// cache hit
br->children = *cp;
} else {
// cache new (or expired)
// Note: use the cache as parent context for
// allocation of result.
br->children = BrowseOrSearchAll
(cds, cds->cache, objectId, criteria);
// set cache
*cp = br->children;
}
}
// Add a reference to the cached result before returning it
if (br->children) {
talloc_increase_ref_count (br->children);
talloc_set_destructor (br, DestroyResult);
}
ithread_mutex_unlock (&cds->cache_mutex);
}
if (br->children == NULL) {
talloc_free (br);
br = NULL;
}
return br;
}
//#define TETRAHEDRON
void
glsl_R_DrawAlias (void)
{
#ifdef TETRAHEDRON
static aliasvrt_t debug_verts[] = {
{{ 0, 0}, {-18918,-18918,-18918}, { 0, 0, 0}},
{{ 0,300}, { 18918, 18918,-18918}, {255,255, 0}},
{{300,300}, {-18918, 18918, 18918}, { 0,255,255}},
{{300, 0}, { 18918,-18918, 18918}, {255, 0,255}},
};
static GLushort debug_indices[] = {
0, 1, 2,
0, 3, 1,
1, 3, 2,
0, 2, 3,
};
#endif
static quat_t color = { 1, 1, 1, 1};
static vec3_t lightvec;
float ambient;
float shadelight;
float skin_size[2];
float blend;
entity_t *ent = currententity;
model_t *model = ent->model;
aliashdr_t *hdr;
vec_t norm_mat[9];
mat4_t mvp_mat;
int skin_tex;
int colormap;
aliasvrt_t *pose1 = 0; // VBO's are null based
aliasvrt_t *pose2 = 0; // VBO's are null based
if (!(hdr = model->aliashdr))
hdr = Cache_Get (&model->cache);
calc_lighting (ent, &ambient, &shadelight, lightvec);
// we need only the rotation for normals.
VectorCopy (ent->transform + 0, norm_mat + 0);
VectorCopy (ent->transform + 4, norm_mat + 3);
VectorCopy (ent->transform + 8, norm_mat + 6);
// ent model scaling and offset
Mat4Zero (mvp_mat);
mvp_mat[0] = hdr->mdl.scale[0];
mvp_mat[5] = hdr->mdl.scale[1];
mvp_mat[10] = hdr->mdl.scale[2];
mvp_mat[15] = 1;
VectorCopy (hdr->mdl.scale_origin, mvp_mat + 12);
Mat4Mult (ent->transform, mvp_mat, mvp_mat);
Mat4Mult (alias_vp, mvp_mat, mvp_mat);
colormap = glsl_colormap;
if (ent->skin && ent->skin->auxtex)
colormap = ent->skin->auxtex;
if (ent->skin && ent->skin->texnum) {
skin_t *skin = ent->skin;
skin_tex = skin->texnum;
} else {
maliasskindesc_t *skindesc;
skindesc = R_AliasGetSkindesc (ent->skinnum, hdr);
skin_tex = skindesc->texnum;
}
blend = R_AliasGetLerpedFrames (ent, hdr);
pose1 += ent->pose1 * hdr->poseverts;
pose2 += ent->pose2 * hdr->poseverts;
skin_size[0] = hdr->mdl.skinwidth;
skin_size[1] = hdr->mdl.skinheight;
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglBindTexture (GL_TEXTURE_2D, colormap);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglBindTexture (GL_TEXTURE_2D, skin_tex);
#ifndef TETRAHEDRON
qfeglBindBuffer (GL_ARRAY_BUFFER, hdr->posedata);
qfeglBindBuffer (GL_ELEMENT_ARRAY_BUFFER, hdr->commands);
#endif
qfeglVertexAttrib4fv (quake_mdl.colora.location, color);
qfeglVertexAttrib4fv (quake_mdl.colorb.location, color);
qfeglUniform1f (quake_mdl.blend.location, blend);
qfeglUniform1f (quake_mdl.ambient.location, ambient);
qfeglUniform1f (quake_mdl.shadelight.location, shadelight);
qfeglUniform3fv (quake_mdl.lightvec.location, 1, lightvec);
qfeglUniform2fv (quake_mdl.skin_size.location, 1, skin_size);
qfeglUniformMatrix4fv (quake_mdl.mvp_matrix.location, 1, false, mvp_mat);
qfeglUniformMatrix3fv (quake_mdl.norm_matrix.location, 1, false, norm_mat);
#ifndef TETRAHEDRON
set_arrays (&quake_mdl.vertexa, &quake_mdl.normala, &quake_mdl.sta, pose1);
set_arrays (&quake_mdl.vertexb, &quake_mdl.normalb, &quake_mdl.stb, pose2);
qfeglDrawElements (GL_TRIANGLES, 3 * hdr->mdl.numtris,
GL_UNSIGNED_SHORT, 0);
#else
set_arrays (&quake_mdl.vertexa, &quake_mdl.normala, &quake_mdl.sta,
debug_verts);
set_arrays (&quake_mdl.vertexb, &quake_mdl.normalb, &quake_mdl.stb,
debug_verts);
qfeglDrawElements (GL_TRIANGLES,
sizeof (debug_indices) / sizeof (debug_indices[0]),
GL_UNSIGNED_SHORT, debug_indices);
#endif
if (!model->aliashdr)
Cache_Release (&model->cache);
}
GOOD_OR_BAD OWQ_Cache_Get(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
// do check here to avoid needless processing
if (IsUncachedDir(pn) || IsAlarmDir(pn)) {
return gbBAD;
}
switch (pn->selected_filetype->change) {
case fc_simultaneous_temperature:
return Cache_Get_Simultaneous(simul_temp, owq) ;
case fc_simultaneous_voltage:
return Cache_Get_Simultaneous(simul_volt, owq) ;
default:
break ;
}
if (pn->extension == EXTENSION_ALL) {
switch (pn->selected_filetype->format) {
case ft_ascii:
case ft_vascii:
case ft_alias:
case ft_binary:
return gbBAD; // string arrays not supported
case ft_integer:
case ft_unsigned:
case ft_yesno:
case ft_date:
case ft_float:
case ft_pressure:
case ft_temperature:
case ft_tempgap:
return Cache_Get_Strict(OWQ_array(owq), (pn->selected_filetype->ag->elements) * sizeof(union value_object), pn);
default:
return gbBAD;
}
} else {
switch (pn->selected_filetype->format) {
case ft_ascii:
case ft_vascii:
case ft_alias:
case ft_binary:
if (OWQ_offset(owq) > 0) {
return gbBAD;
}
OWQ_length(owq) = OWQ_size(owq);
return Cache_Get(OWQ_buffer(owq), &OWQ_length(owq), pn);
case ft_integer:
case ft_unsigned:
case ft_yesno:
case ft_date:
case ft_float:
case ft_pressure:
case ft_temperature:
case ft_tempgap:
return Cache_Get_Strict(&OWQ_val(owq), sizeof(union value_object), pn);
default:
return gbBAD;
}
}
}
/* Does cache get, but doesn't allow play in data size */
static GOOD_OR_BAD Cache_Get_Strict(void *data, size_t dsize, const struct parsedname *pn)
{
size_t size = dsize;
RETURN_BAD_IF_BAD( Cache_Get(data, &size, pn) ) ;
return ( dsize == size) ? gbGOOD : gbBAD ;
}
