nzp-team/dquakeplus
0
0
Fork 0
mirror of https://github.com/nzp-team/dquakeplus.git synced 2024-11-25 21:31:49 +00:00
Code Issues Projects Releases Packages Wiki Activity
dquakeplus/source/psp/video_hardware_hlmdl.cpp
Shpuld Shpuldson 05e611b7f2 clean up code, fix one memory leak
2023-09-26 22:44:11 +03:00

905 lines
29 KiB
C++
Raw Blame History

extern"C"
{
#include "../quakedef.h"
}
/*
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Half-Life Model Renderer (Experimental) Copyright (C) 2001 James 'Ender' Brown [ender@quakesrc.org] This program is
free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
details. You should have received a copy of the GNU General Public License along with this program; if not, write
to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. fromquake.h -
render.c - apart from calculations (mostly range checking or value conversion code is a mix of standard Quake 1
meshing, and vertex deforms. The rendering loop uses standard Quake 1 drawing, after SetupBones deforms the vertex.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Also, please note that it won't do all hl models....
Nor will it work 100%
++++++++++++++++++++++++++
modify by Crow_bar 2009
10.08.09
++++++++++++++++++++++++++
*/
#include "video_hardware_hlmdl.h"
#include <pspgu.h>
#include <pspgum.h>
#include <list>
extern model_t *loadmodel;
extern vec3_t lightcolor; // LordHavoc: .lit support
extern entity_t *currententity;
extern float *shadedots;
extern vec3_t shadevector;
extern float shadelight, ambientlight;
#define NUMVERTEXNORMALS 162
extern float r_avertexnormals[NUMVERTEXNORMALS][3];
#define SHADEDOT_QUANT 16
extern float r_avertexnormal_dots[SHADEDOT_QUANT][256];
void QuaternionGLMatrix(float x, float y, float z, float w, vec4_t *GLM)
{
GLM[0][0] = 1 - 2 * y * y - 2 * z * z;
GLM[1][0] = 2 * x * y + 2 * w * z;
GLM[2][0] = 2 * x * z - 2 * w * y;
GLM[0][1] = 2 * x * y - 2 * w * z;
GLM[1][1] = 1 - 2 * x * x - 2 * z * z;
GLM[2][1] = 2 * y * z + 2 * w * x;
GLM[0][2] = 2 * x * z + 2 * w * y;
GLM[1][2] = 2 * y * z - 2 * w * x;
GLM[2][2] = 1 - 2 * x * x - 2 * y * y;
}
/*
=======================================================================================================================
QuaternionGLAngle - Convert a GL angle to a quaternion matrix
=======================================================================================================================
*/
void QuaternionGLAngle(const vec3_t angles, vec4_t quaternion)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
float yaw = angles[2] * 0.5;
float pitch = angles[1] * 0.5;
float roll = angles[0] * 0.5;
float siny = sin(yaw);
float cosy = cos(yaw);
float sinp = sin(pitch);
float cosp = cos(pitch);
float sinr = sin(roll);
float cosr = cos(roll);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
quaternion[0] = sinr * cosp * cosy - cosr * sinp * siny;
quaternion[1] = cosr * sinp * cosy + sinr * cosp * siny;
quaternion[2] = cosr * cosp * siny - sinr * sinp * cosy;
quaternion[3] = cosr * cosp * cosy + sinr * sinp * siny;
}
matrix3x4 transform_matrix[128]; /* Vertex transformation matrix */
int g_chrome[MAXSTUDIOVERTS][2]; // texture coords for surface normals
int g_chromeage[MAXSTUDIOBONES]; // last time chrome vectors were updated
vec3_t g_chromeup[MAXSTUDIOBONES]; // chrome vector "up" in bone reference frames
vec3_t g_chromeright[MAXSTUDIOBONES]; // chrome vector "right" in bone reference frames
vec3_t g_vright = { 50, 50, 0 };
vec3_t *g_pvlightvalues;
vec3_t g_blightvec[MAXSTUDIOBONES]; // light vectors in bone reference frames
vec3_t g_lightvalues[MAXSTUDIOVERTS]; // light surface normals
vec3_t g_lightvec; // light vector in model reference frame
vec3_t g_lightcolor;
int g_smodels_total; // cookie
vec3_t m_angles;
void GL_Draw_HL_AliasFrame(short *order, vec3_t *transformed, float tex_w, float tex_h, float *lv);
void GL_Draw_HL_AliasChrome(short *order, vec3_t *transformed, float tex_w, float tex_h, float *lv);
/*
=======================================================================================================================
Mod_LoadHLModel - read in the model's constituent parts
=======================================================================================================================
*/
extern char loadname[];
extern int nonetexture;
qboolean Mod_LoadHLModel (model_t *mod, void *buffer)
{
/*~~*/
int i;
hlmodelcache_t *model;
hlmdl_header_t *header;
hlmdl_tex_t *tex;
hlmdl_bone_t *bones;
hlmdl_bonecontroller_t *bonectls;
int start, end, total;
/*~~*/
start = Hunk_LowMark ();
//load the model into hunk
model = static_cast<hlmodelcache_t*>(Hunk_Alloc(sizeof(hlmodelcache_t)));
header = static_cast<hlmdl_header_t*>(Hunk_Alloc(com_filesize));
memcpy_vfpu(header, buffer, com_filesize);
if (header->version != 10)
{
Con_Printf("Cannot load model %s - unknown version %i\n", mod->name, header->version);
Hunk_FreeToLowMark(start);
return qfalse;
}
tex = (hlmdl_tex_t *) ((byte *) header + header->textures);
bones = (hlmdl_bone_t *) ((byte *) header + header->boneindex);
bonectls = (hlmdl_bonecontroller_t *) ((byte *) header + header->controllerindex);
model->header = (char *)header - (char *)model;
Con_Printf("HLMDL Load: header");
model->textures = (char *)tex - (char *)model;
Con_Printf(", tex");
model->bones = (char *)bones - (char *)model;
Con_Printf(", bones");
model->bonectls = (char *)bonectls - (char *)model;
Con_Printf(", bonectls\n");
for(i = 0; i < header->numtextures; i++)
{
tex[i].i = GL_LoadPalTex (tex[i].name, tex[i].w, tex[i].h, (byte *) header + tex[i].i, qtrue, GU_LINEAR, 0, (byte *) header + tex[i].w * tex[i].h + tex[i].i, PAL_RGB);
}
//
// move the complete, relocatable alias model to the cache
//
end = Hunk_LowMark ();
total = end - start;
mod->type = mod_halflife;
Cache_Alloc (&mod->cache, total, loadname);
if (!mod->cache.data)
return qfalse;
memcpy_vfpu(mod->cache.data, model, total);
Hunk_FreeToLowMark (start);
return qtrue;
}
/*
======================================================================================================================
HL_CurSequence - return the current sequence
======================================================================================================================
*/
int HL_CurSequence(hlmodel_t model)
{
return model.sequence;
}
/*
=======================================================================================================================
HL_NewSequence - animation control (just some range checking really)
=======================================================================================================================
*/
int HL_NewSequence(hlmodel_t *model, int _inew)
{
if(_inew < 0)
_inew = model->header->numseq - 1;
else if(_inew >= model->header->numseq)
_inew = 0;
model->sequence = _inew;
model->frame = 0;
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hlmdl_sequencelist_t *pseqdesc;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
if(_inew == 0)
{
pseqdesc = (hlmdl_sequencelist_t *) ((byte *) model->header + model->header->seqindex) + model->sequence;
}
else
{
pseqdesc = (hlmdl_sequencelist_t *) ((byte *) model->header + model->header->seqindex) + model->sequence;
}
Sys_Printf("Current Sequence: %s\n", pseqdesc->name);
}
return model->sequence;
}
/*
=======================================================================================================================
HL_SetController - control where the model is facing (upper body usually)
=======================================================================================================================
*/
void HL_SetController(hlmodel_t *model, int num, float value)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int real, limit;
hlmdl_bonecontroller_t *control = (hlmdl_bonecontroller_t *)
((byte *) model->header + model->header->controllerindex);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
if(num >= model->header->numcontrollers) return;
if(num == 4)
{
limit = 64;
}
else
{
limit = 255;
}
if(control->type & (0x0008 | 0x0010 | 0x0020))
{
if(control->end < control->start) value = -value;
if(control->start + 359.0 >= control->end)
{
if(value > ((control->start + control->end) / 2.0) + 180) value = value - 360;
if(value < ((control->start + control->end) / 2.0) - 180) value = value + 360;
}
else
{
if(value > 360)
value = value - (int) (value / 360.0) * 360.0;
else if(value < 0)
value = value + (int) ((value / -360.0) + 1) * 360.0;
}
}
real = limit * (value - control[num].start) / (control[num].end - control[num].start);
if(real < 0) real = 0;
if(real > limit) real = limit;
model->controller[num] = real;
}
/*
=======================================================================================================================
HL_CalculateBones - calculate bone positions - quaternion+vector in one function
=======================================================================================================================
*/
void HL_CalculateBones(int offset, int frame, vec4_t adjust, hlmdl_bone_t *bone, hlmdl_anim_t *animation, float *destination)
{
/*~~~~~~~~~~*/
int i;
vec3_t angle;
/*~~~~~~~~~~*/
/* For each vector */
for(i = 0; i < 3; i++)
{
/*~~~~~~~~~~~~~~~*/
int o = i + offset; /* Take the value offset - allows quaternion & vector in one function */
/*~~~~~~~~~~~~~~~*/
angle[i] = bone->value[o]; /* Take the bone value */
if(animation->offset[o] != 0)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int tempframe = frame;
hlmdl_animvalue_t *animvalue = (hlmdl_animvalue_t *) ((byte *) animation + animation->offset[o]);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/* find values including the required frame */
while(animvalue->num.total <= tempframe)
{
tempframe -= animvalue->num.total;
animvalue += animvalue->num.valid + 1;
}
if(animvalue->num.valid > tempframe)
{
if(animvalue->num.valid > (tempframe + 1))
angle[i] += animvalue[tempframe + 1].value * 1; // + 0 * animvalue[tempframe + 2].value * bone->scale[o];
else
angle[i] = animvalue[animvalue->num.valid].value;
angle[i] = bone->value[o] + angle[i] * bone->scale[o];
}
else
{
if(animvalue->num.total <= tempframe + 1)
{
angle[i] +=
(animvalue[animvalue->num.valid].value * 1 +
0 * animvalue[animvalue->num.valid + 2].value) *
bone->scale[o];
}
else
{
angle[i] += animvalue[animvalue->num.valid].value * bone->scale[o];
}
}
}
if(bone->bonecontroller[o] != -1) { /* Add the programmable offset. */
angle[i] += adjust[bone->bonecontroller[o]];
}
}
if(offset < 3)
{
VectorCopy(angle, destination); /* Just a standard vector */
}
else
{
QuaternionGLAngle(angle, destination); /* A quaternion */
}
}
/*
=======================================================================================================================
HL_CalcBoneAdj - Calculate the adjustment values for the programmable controllers
=======================================================================================================================
*/
void HL_CalcBoneAdj(hlmodel_t *model)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int i;
float value;
hlmdl_bonecontroller_t *control = (hlmdl_bonecontroller_t *)
((byte *) model->header + model->header->controllerindex);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
for(i = 0; i < model->header->numcontrollers; i++)
{
/*~~~~~~~~~~~~~~~~~~~~~*/
int j = control[i].index;
/*~~~~~~~~~~~~~~~~~~~~~*/
/*
if(control[i].type & 0x8000)
{
value = model->controller[j] + control[i].start;
}
else
{
value = model->controller[j];
if(value < 0)
value = 0;
else if(value > 1.0)
value = 1.0;
value = (1.0 - value) * control[i].start + value * control[i].end;
}
*/
if (j <= 3)
{
// check for 360% wrapping
if (control[i].type & STUDIO_RLOOP)
{
value = model->controller[j] * (360.0/256.0) + control[i].start;
}
else
{
value = model->controller[j] / 255.0;
if (value < 0)
value = 0;
if (value > 1.0)
value = 1.0;
value = (1.0 - value) * control[i].start + value * control[i].end;
}
// Con_DPrintf( "%d %d %f : %f\n", m_controller[i], m_prevcontroller[i], value, dadt );
}
else
{
value = /*model->mouth*/1 / 64.0;
if (value > 1.0)
value = 1.0;
value = (1.0 - value) * control[i].start + value * control[i].end;
// Con_DPrintf("%d %f\n", mouthopen, value );
}
/* Rotational controllers need their values converted */
switch(control[i].type & STUDIO_TYPES)
{
case STUDIO_XR:
case STUDIO_YR:
case STUDIO_ZR:
model->adjust[i] = value * (M_PI / 180.0);
break;
case STUDIO_X:
case STUDIO_Y:
case STUDIO_Z:
model->adjust[i] = value;
break;
}
}
}
/*
=======================================================================================================================
HL_SetupBones - determine where vertex should be using bone movements
=======================================================================================================================
*/
void HL_SetupBones(hlmodel_t *model)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int i;
float matrix[3][4];
static vec3_t positions[128];
static vec4_t quaternions[128];
hlmdl_sequencelist_t *sequence = (hlmdl_sequencelist_t *) ((byte *) model->header + model->header->seqindex) +
model->sequence;
hlmdl_sequencedata_t *sequencedata = (hlmdl_sequencedata_t *)
((byte *) model->header + model->header->seqgroups) +
sequence->seqindex;
hlmdl_anim_t *animation = (hlmdl_anim_t *)
((byte *) model->header + sequencedata->data + sequence->index);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
HL_CalcBoneAdj(model); /* Deal with programmable controllers */
if(sequence->motiontype & STUDIO_X)
positions[sequence->motionbone][0] = 0.0;
if(sequence->motiontype & STUDIO_Y)
positions[sequence->motionbone][1] = 0.0;
if(sequence->motiontype & STUDIO_Z)
positions[sequence->motionbone][2] = 0.0;
/* Sys_Printf("Frame: %i\n", model->frame); */
for(i = 0; i < model->header->numbones; i++)
{
/*
* There are two vector offsets in the structure. The first seems to be the
* positions of the bones, the second the quats of the bone matrix itself. We
* convert it inside the routine - Inconsistant, but hey.. so's the whole model
* format.
*/
HL_CalculateBones(0, model->frame, model->adjust, model->bones + i, animation + i, positions[i]);
HL_CalculateBones(3, model->frame, model->adjust, model->bones + i, animation + i, quaternions[i]);
/* FIXME: Blend the bones and make them cry :) */
QuaternionGLMatrix(quaternions[i][0], quaternions[i][1], quaternions[i][2], quaternions[i][3], matrix);
matrix[0][3] = positions[i][0];
matrix[1][3] = positions[i][1];
matrix[2][3] = positions[i][2];
/* If we have a parent, take the addition. Otherwise just copy the values */
if(model->bones[i].parent>=0)
{
R_ConcatTransforms(transform_matrix[model->bones[i].parent], matrix, transform_matrix[i]);
}
else
{
memcpy_vfpu(transform_matrix[i], matrix, 12 * sizeof(float));
}
}
}
/*
=======================================================================================================================
Chrome
=======================================================================================================================
*/
/*
================
TransformFinalVert
================
*/
void Lighting (float *lv, int bone, int flags, vec3_t normal)
{
float illum;
float lightcos;
illum = ambientlight;
if (flags & STUDIO_NF_FLATSHADE)
{
illum += shadelight * 0.8;
}
else
{
float r;
lightcos = DotProduct (normal, g_blightvec[bone]); // -1 colinear, 1 opposite
if (lightcos > 1.0)
lightcos = 1;
illum += shadelight;
//r = g_lambert;
//if (r <= 1.0)
r = 1.0;
lightcos = (lightcos + (r - 1.0)) / r; // do modified hemispherical lighting
if (lightcos > 0.0)
{
illum -= shadelight * lightcos;
}
if (illum <= 0)
illum = 0;
}
if (illum > 255)
illum = 255;
*lv = illum / 255.0; // Light from 0 to 1.0
}
void VectorIRotate (const vec3_t in1, const float in2[3][4], vec3_t out)
{
out[0] = in1[0]*in2[0][0] + in1[1]*in2[1][0] + in1[2]*in2[2][0];
out[1] = in1[0]*in2[0][1] + in1[1]*in2[1][1] + in1[2]*in2[2][1];
out[2] = in1[0]*in2[0][2] + in1[1]*in2[1][2] + in1[2]*in2[2][2];
}
void SetupLighting ( hlmodel_t *model )
{ // dr_mabuse1981: edited abit to make halflife model NOT look ughly and for Shpulds model brightness cvar
int i;
if(r_model_brightness.value)
ambientlight = 256;
else
ambientlight = 128;
shadelight = 33;
g_lightvec[0] = shadevector[0];
g_lightvec[1] = shadevector[1];
g_lightvec[2] = shadevector[2];
g_lightcolor[0] = lightcolor[0];
g_lightcolor[1] = lightcolor[1];
g_lightcolor[2] = lightcolor[2];
// TODO: only do it for bones that actually have textures
for (i = 0; i < model->header->numbones; i++)
{
VectorIRotate( g_lightvec, transform_matrix[i], g_blightvec[i] );
}
}
void Chrome (int *pchrome, int bone, vec3_t normal)
{
float n;
if (g_chromeage[bone] != g_smodels_total)
{
// calculate vectors from the viewer to the bone. This roughly adjusts for position
vec3_t chromeupvec; // g_chrome t vector in world reference frame
vec3_t chromerightvec; // g_chrome s vector in world reference frame
vec3_t tmp; // vector pointing at bone in world reference frame
VectorScale( m_angles, -1, tmp );
tmp[0] += transform_matrix[bone][0][3];
tmp[1] += transform_matrix[bone][1][3];
tmp[2] += transform_matrix[bone][2][3];
VectorNormalize( tmp );
CrossProduct( tmp, g_vright, chromeupvec );
VectorNormalize( chromeupvec );
CrossProduct( tmp, chromeupvec, chromerightvec );
VectorNormalize( chromerightvec );
VectorIRotate( chromeupvec, transform_matrix[bone], g_chromeup[bone] );
VectorIRotate( chromerightvec, transform_matrix[bone], g_chromeright[bone] );
g_chromeage[bone] = g_smodels_total;
}
// calc s coord
n = DotProduct( normal, g_chromeright[bone] );
pchrome[0] = (n + 1.0) * 32; // FIX: make this a float
// calc t coord
n = DotProduct( normal, g_chromeup[bone] );
pchrome[1] = (n + 1.0) * 32; // FIX: make this a float
}
/*
=======================================================================================================================
R_Draw_HL_AliasModel - main drawing function
=======================================================================================================================
*/
void R_DrawHLModel(entity_t *curent)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hlmodelcache_t *modelc = static_cast<hlmodelcache_t*>(Mod_Extradata(curent->model));
hlmodel_t model;
int b, m, v;
short *skins;
hlmdl_sequencelist_t *sequence;
float *lv;
float lv_tmp;
int lnum;
vec3_t dist;
float add;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//general model
model.header = (hlmdl_header_t *) ((char *)modelc + modelc->header);
model.textures = (hlmdl_tex_t *) ((char *)modelc + modelc->textures);
model.bones = (hlmdl_bone_t *) ((char *)modelc + modelc->bones);
model.bonectls = (hlmdl_bonecontroller_t *) ((char *)modelc + modelc->bonectls);
//specific to entity
model.sequence = curent->frame;
model.frame = 0;
model.frametime = 0;
HL_NewSequence(&model, curent->frame);
skins = (short *) ((byte *) model.header + model.header->skins);
sequence = (hlmdl_sequencelist_t *) ((byte *) model.header + model.header->seqindex) +
model.sequence;
model.controller[0] = curent->bonecontrols[0];
model.controller[1] = curent->bonecontrols[1];
model.controller[2] = curent->bonecontrols[2];
model.controller[3] = curent->bonecontrols[3];
model.frametime += (cl.time /* - cl.lerpents[curent->keynum].framechange*/)*sequence->timing;
if (model.frametime>=1)
{
model.frame += (int) model.frametime;
model.frametime -= (int)model.frametime;
}
if (!sequence->numframes)
return;
/*
if(model.frame >= sequence->numframes)
model.frame %= sequence->numframes;
*/
model.frame = curent->frame; // dr_mabuse1981: This makes your Halflife model frame based (only for sequence 0 atm but better than the old shit.)
if (sequence->motiontype)
model.frame = sequence->numframes-1;
sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
sceGuShadeModel(GU_SMOOTH);
Con_Printf("%s %i\n", sequence->name, sequence->unknown1[0]);
sceGumPushMatrix();
for(int i = 0; i < 3; i++) m_angles[i] = currententity->angles[i];
R_LightPoint(curent->origin); // LordHavoc: lightcolor is all that matters from this
for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
{
if (cl_dlights[lnum].die >= cl.time)
{
VectorSubtract (currententity->origin,
cl_dlights[lnum].origin,
dist);
add = cl_dlights[lnum].radius - Length(dist);
// LordHavoc: .lit support begin
if (add > 0)
{
lightcolor[0] += add * cl_dlights[lnum].color[0];
lightcolor[1] += add * cl_dlights[lnum].color[1];
lightcolor[2] += add * cl_dlights[lnum].color[2];
}
// LordHavoc: .lit support end
}
}
VectorScale(lightcolor, 1.0f / 200.0f, lightcolor);
float an;
an = curent->angles[1]/180*M_PI;
shadevector[0] = cosf(-an);
shadevector[1] = sinf(-an);
shadevector[2] = 1;
VectorNormalize (shadevector);
R_BlendedRotateForEntity(curent, 0);
HL_SetupBones(&model); /* Setup the bones */
SetupLighting(&model); /* Setup the light */
g_smodels_total++; // render data cache cookie
g_pvlightvalues = &g_lightvalues[0];
/* Manipulate each mesh directly */
for(b = 0; b < model.header->numbodyparts; b++)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hlmdl_bodypart_t *bodypart = (hlmdl_bodypart_t *) ((byte *) model.header + model.header->bodypartindex) +
b;
int bodyindex = (0 / bodypart->base) % bodypart->nummodels;
hlmdl_model_t *amodel = (hlmdl_model_t *) ((byte *) model.header + bodypart->modelindex) + bodyindex;
byte *bone = ((byte *) model.header + amodel->vertinfoindex);
byte *nbone = ((byte *) model.header + amodel->norminfoindex);
vec3_t *verts = (vec3_t *) ((byte *) model.header + amodel->vertindex);
vec3_t *norms = (vec3_t *) ((byte *) model.header + amodel->normindex);
vec3_t transformed[2048];
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
for(v = 0; v < amodel->numverts; v++) // Transform per the matrix
{
VectorTransform(verts[v], transform_matrix[bone[v]], transformed[v]);
}
lv = (float *)g_pvlightvalues;
for(m = 0; m < amodel->nummesh; m++)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hlmdl_mesh_t *mesh = (hlmdl_mesh_t *) ((byte *) model.header + amodel->meshindex) + m;
float tex_w = 1.0f / model.textures[skins[mesh->skinindex]].w;
float tex_h = 1.0f / model.textures[skins[mesh->skinindex]].h;
int flags = model.textures[skins[mesh->skinindex]].flags;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
for (int c = 0; c < mesh->numnorms; c++, lv += 3, norms++, nbone++)
{
Lighting (&lv_tmp, *nbone, flags, (float *)norms);
// FIX: move this check out of the inner loop
if (flags & STUDIO_NF_CHROME)
Chrome(g_chrome[(float (*)[3])lv - g_pvlightvalues], *nbone, (float *)norms );
lv[0] = lv_tmp * g_lightcolor[0];
lv[1] = lv_tmp * g_lightcolor[1];
lv[2] = lv_tmp * g_lightcolor[2];
}
if (model.textures[skins[mesh->skinindex]].flags & STUDIO_NF_CHROME)
{
GL_Bind(model.textures[skins[mesh->skinindex]].i);
GL_Draw_HL_AliasChrome((short *) ((byte *) model.header + mesh->index), transformed, tex_w, tex_h, lv);
}
else
{
GL_Bind(model.textures[skins[mesh->skinindex]].i);
GL_Draw_HL_AliasFrame((short *) ((byte *) model.header + mesh->index), transformed, tex_w, tex_h, lv);
}
}
}
sceGuShadeModel(GU_FLAT);
sceGumPopMatrix();
sceGumUpdateMatrix();
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
}
/*
=======================================================================================================================
GL_Draw_HL_AliasFrame - clip and draw all triangles
=======================================================================================================================
*/
void GL_Draw_HL_AliasFrame(short *order, vec3_t *transformed, float tex_w, float tex_h, float *lv)
{
int count = 0;
while (1)
{
count = *order++;
if (!count)
break; // done
int prim;
if(count < 0)
{
count = -count;
prim = GU_TRIANGLE_FAN;
}
else
{
prim = GU_TRIANGLE_STRIP;
}
// Allocate the vertices.
struct vertex
{
float u, v;
unsigned int color;
float x, y, z;
};
vertex* const out = static_cast<vertex*>(sceGuGetMemory(sizeof(vertex) * count));
for (int vertex_index = 0; vertex_index < count; ++vertex_index)
{
float *verts = transformed[order[0]];
out[vertex_index].u = order[2] * tex_w;
out[vertex_index].v = order[3] * tex_h;
order += 4;
lv = g_pvlightvalues[order[1]];
//color clamp
for(int i = 0; i < 3; i++)
{
if(lv[i] > 1)
lv[i] = 1;
if(lv[i] < 0)
lv[i] = 0;
}
out[vertex_index].x = verts[0];
out[vertex_index].y = verts[1];
out[vertex_index].z = verts[2];
out[vertex_index].color = GU_COLOR(lv[0], lv[1], lv[2], 1.0f);
}
if(r_showtris.value)
{
sceGuDisable(GU_TEXTURE_2D);
}
sceGuDrawArray(r_showtris.value ? GU_LINE_STRIP : prim, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_COLOR_8888, count, 0, out);
if(r_showtris.value)
{
sceGuEnable(GU_TEXTURE_2D);
}
}
}
void GL_Draw_HL_AliasChrome(short *order, vec3_t *transformed, float tex_w, float tex_h, float *lv)
{
int count = 0;
while (1)
{
count = *order++;
if (!count)
break; // done
int prim;
if(count < 0)
{
count = -count;
prim = GU_TRIANGLE_FAN;
}
else
{
prim = GU_TRIANGLE_STRIP;
}
// Allocate the vertices.
struct vertex
{
float u, v;
unsigned int color;
float x, y, z;
};
vertex* const out = static_cast<vertex*>(sceGuGetMemory(sizeof(vertex) * count));
for (int vertex_index = 0; vertex_index < count; ++vertex_index)
{
float *verts = transformed[order[0]];
out[vertex_index].u = g_chrome[order[1]][0] * tex_w;
out[vertex_index].v = g_chrome[order[1]][1] * tex_h;
order += 4;
lv = g_pvlightvalues[order[1]];
//color clamp
for(int i = 0; i < 3; i++)
{
if(lv[i] > 1)
lv[i] = 1;
if(lv[i] < 0)
lv[i] = 0;
}
out[vertex_index].x = verts[0];
out[vertex_index].y = verts[1];
out[vertex_index].z = verts[2];
out[vertex_index].color = GU_COLOR(lv[0], lv[1], lv[2], 1.0f);
}
if(r_showtris.value)
{
sceGuDisable(GU_TEXTURE_2D);
}
sceGuDrawArray(r_showtris.value ? GU_LINE_STRIP : prim, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_COLOR_8888, count, 0, out);
if(r_showtris.value)
{
sceGuEnable(GU_TEXTURE_2D);
}
}
}
Reference in a new issue View git blame Copy permalink