Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-28 21:57:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
openmohaa/code/cgame/cg_beam.cpp
smallmodel 5333c7ff4a
Removed empty line before opening braces
2023-07-05 20:52:55 +02:00

1601 lines
40 KiB
C++
Raw Blame History

/*
===========================================================================
Copyright (C) 2023 the OpenMoHAA team
This file is part of OpenMoHAA source code.
OpenMoHAA source code 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.
OpenMoHAA source code 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 OpenMoHAA source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
// DESCRIPTION:
// Beam effects
#include "cg_local.h"
#include "vector.h"
#include "container.h"
#include "cg_commands.h"
class beam_t : public Class
{
public:
beam_t();
int entity;
qhandle_t hModel;
int endtime;
Vector start, end;
float scale;
float alpha;
int flags;
int parent;
float max_offset;
float min_offset;
int numSubdivisions;
int overlap;
int beamshader;
byte shaderRGBA[4];
int update_time;
int delay;
float life;
int numspherebeams;
float sphereradius;
int toggletime;
int toggledelay;
qboolean active;
float alphastep;
int renderfx;
str name;
beam_t* next;
beam_t* prev;
};
beam_t::beam_t()
{
entity = 0;
hModel = 0;
endtime = 0;
scale = 0;
alpha = 0;
flags = 0;
parent = ENTITYNUM_NONE;
max_offset = 0;
min_offset = 0;
numSubdivisions = 0;
overlap = 0;
beamshader = 0;
update_time = 0;
delay = 0;
life = 0;
numspherebeams = 0;
sphereradius = 0;
toggletime = 0;
toggledelay = 0;
active = 0;
alphastep = 0;
renderfx = 0;
memset(shaderRGBA, 0, 4);
next = NULL;
prev = NULL;
}
beam_t cl_beams[MAX_BEAMS];
beam_t* cl_free_beams;
beam_t* cl_active_beams;
static int seed = 100;
// Recursive beam builder - I don't use it anymore
/*
void CG_BuildRenderBeam_r
(
Vector start,
Vector end,
float angleVar,
int numSubdivisions,
int maxSubdivisions
)
{
if ( numSubdivisions == maxSubdivisions )
{
return;
}
else
{
// subdivide line and call on both halves
numSubdivisions += 1;
mid = ( p1 * 0.5 ) + ( p2 * 0.5 );
int seed = 100;
mid[0] += Q_crandom( &seed ) * angleVar;
mid[1] += Q_crandom( &seed ) * angleVar;
mid[2] += Q_crandom( &seed ) * angleVar;
CG_BuildRendererBeam( p1, mid, angleVar, numSubdivisions, maxSubdivisions, color, beamshader, scale );
CG_BuildRendererBeam( mid, p2, angleVar, numSubdivisions, maxSubdivisions, color, beamshader, scale );
}
}
*/
#define MAX_BEAM_BACKUP 6
#define MAX_BEAM_SEGMENTS 32
typedef struct beamSegment_t
{
polyVert_t points[4];
} beamSegment_t;
typedef struct beamList_t
{
int time;
int updatetime;
int numsegments;
beamSegment_t segments[MAX_BEAM_SEGMENTS];
} beamList_t;
typedef struct beamEnt_t
{
int owner;
int numbeams;
int life;
int renderfx;
beamList_t beamlist[MAX_BEAM_BACKUP];
} beamEnt_t;
Container<beamEnt_t*> beamManager;
void ClientGameCommandManager::InitializeBeams()
{
int i;
beam_t* b;
cl_free_beams = NULL;
cl_active_beams = NULL;
for (i = 0; i < MAX_BEAMS; i++)
{
b = &cl_beams[i];
if (cl_free_beams) {
cl_free_beams->prev = b;
}
b->next = cl_free_beams;
b->prev = 0;
cl_free_beams = b;
}
}
void RemoveBeamList
(
int owner
)
{
int i, num;
num = beamManager.NumObjects();
for (i = 1; i <= num; i++)
{
beamEnt_t* be = beamManager.ObjectAt(i);
if (be->owner == owner)
{
beamManager.RemoveObjectAt(i);
delete be;
return;
}
}
}
beamEnt_t* FindBeamList
(
int owner
)
{
int i, num;
num = beamManager.NumObjects();
for (i = 1; i <= num; i++)
{
beamEnt_t* be = beamManager.ObjectAt(i);
if (be->owner == owner)
return be;
}
return NULL;
}
int CreateNewBeamEntity
(
int owner,
float life
)
{
beamEnt_t* be;
int i, oldest, oldest_time;
be = FindBeamList(owner);
if (!be)
{
be = new beamEnt_t;
if (!be)
cgi.Error(ERR_DROP, "Could not allocate memory for beamEnt.\n");
memset(be, 0, sizeof(beamEnt_t));
memset(be->beamlist, 0, sizeof(beamList_t) * MAX_BEAM_BACKUP);
be->owner = owner;
be->life = life;
beamManager.AddObject(be);
}
// find the oldest beam and overwrite it.
oldest = -1;
oldest_time = 999999999;
for (i = 0; i < MAX_BEAM_BACKUP; i++)
{
// Check for update time
float t = be->beamlist[i].time;
if (!t)
{
oldest = i;
break;
}
if (t < oldest_time)
{
oldest = i;
oldest_time = t;
}
}
// Use the oldest beam for the next beam.
be->beamlist[oldest].numsegments = 0;
be->beamlist[oldest].time = cg.time;
be->beamlist[oldest].updatetime = cg.time + be->life;
return oldest;
}
void RemoveBeamEntity
(
int owner
)
{
RemoveBeamList(owner);
}
void AddBeamSegmentToList
(
int owner,
polyVert_t points[4],
int beamnum,
int segnum,
int renderfx
)
{
beamEnt_t* be;
be = FindBeamList(owner);
if (!be)
{
cgi.DPrintf("Could not find beam entity for owner:%d\n", owner);
return;
}
if (segnum >= MAX_BEAM_SEGMENTS)
return;
be->renderfx = renderfx;
// Copy the 4 points
memcpy(&be->beamlist[beamnum].segments[segnum].points, points, 4 * sizeof(polyVert_t));
// Increase the segment counter
be->beamlist[beamnum].numsegments++;
}
void CG_AddBeamsFromList
(
int owner,
int beamshader
)
{
int i, j, k, l;
float frac, fade;
beamEnt_t* be = FindBeamList(owner);
polyVert_t newpoints[4];
if (!be)
{
return;
}
for (i = 0; i < MAX_BEAM_BACKUP; i++)
{
beamList_t* bl = &be->beamlist[i];
if (!bl->time)
continue;
// Calculate the blend factor for fading
frac = (float)(cg.time - bl->time) / (float)be->life;
fade = 1.0f - frac;
if (fade <= 0)
{
bl->time = 0; // RemoveBeamList( owner );
continue;
}
// Go through each segment and draw it with the new modulate
assert(bl->numsegments < MAX_BEAM_SEGMENTS);
for (j = 0; j < bl->numsegments; j++)
{
memcpy(newpoints, bl->segments[j].points, 4 * sizeof(polyVert_t));
for (k = 0; k < 4; k++)
{
for (l = 0; l < 4; l++)
{
newpoints[k].modulate[l] = bl->segments[j].points[k].modulate[l] * fade;
}
}
cgi.R_AddPolyToScene(beamshader, 4, newpoints, be->renderfx);
}
}
}
void RenderSegment
(
Vector pt1a,
Vector pt1b,
Vector pt2a,
Vector pt2b,
byte modulate[4],
int beamshader,
int renderfx
)
{
int i, j;
polyVert_t points[4];
VectorCopy(pt1a, points[0].xyz);
VectorCopy(pt2a, points[1].xyz);
VectorCopy(pt2b, points[2].xyz);
VectorCopy(pt1b, points[3].xyz);
points[0].st[0] = 1; points[0].st[1] = 1;
points[1].st[0] = 0; points[1].st[1] = 1;
points[2].st[0] = 0; points[2].st[1] = 0;
points[3].st[0] = 1; points[3].st[1] = 0;
// Set the color of the verts
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
points[i].modulate[j] = modulate[j];
}
}
// Add a segment to the list
cgi.R_AddPolyToScene(beamshader, 4, points, renderfx);
}
const int MAX_SUBPOINTS = 256;
static Vector subpoints[MAX_SUBPOINTS];
static int ptctr = 0;
/*
===============
CG_Subdivide
a, b, and c are control points.
the subdivided sequence will be: a, out1, out2, out3, c
===============
*/
static void CG_Subdivide(Vector a, Vector b, Vector c, Vector& out1, Vector& out2, Vector& out3)
{
out1 = 0.5 * (a + b);
out3 = 0.5 * (b + c);
out2 = 0.5 * (out1 + out3);
}
void CG_MultiBeamBegin
(
void
)
{
ptctr = 0;
}
void CG_MultiBeamAddPoints
(
vec3_t start,
vec3_t end,
int numsegments,
int flags,
float minoffset,
float maxoffset,
qboolean addstartpoint
)
{
Vector delta, dir, randdir;
float length;
int i;
if (ptctr > MAX_SUBPOINTS)
return;
if (addstartpoint)
{
subpoints[ptctr++] = start;
}
delta = Vector(end) - Vector(start);
length = delta.length();
length /= numsegments;
// get the dir of beam
dir = delta;
dir.normalize();
for (i = 1; i < numsegments; i++)
{
Vector newpt;
if (ptctr > MAX_SUBPOINTS)
return;
randdir = Vector(crandom(), crandom(), crandom());
newpt = Vector(start) + dir * i * length;
newpt += minoffset * randdir + maxoffset * randdir;
subpoints[ptctr++] = newpt;
}
subpoints[ptctr++] = end;
}
void CG_MultiBeamEnd
(
float scale,
int renderfx,
const char* beamshadername,
byte modulate[4],
int flags,
int owner,
float life
)
{
Vector prevpt, currpt;
Vector p1, p2, p3, p4, v1, v2, up, currpt1, currpt2, prevpt1, prevpt2;
qboolean prevptvalid = false;
int i, beamshader;
beamshader = cgi.R_RegisterShader(beamshadername);
prevpt = subpoints[0];
prevptvalid = false;
for (i = 1; i < ptctr; i++)
{
currpt = subpoints[i];
// Generate the up vector
v1 = prevpt - cg.refdef.vieworg;
v2 = currpt - cg.refdef.vieworg;
#if 0
cgi.R_DebugLine(prevpt, currpt, 1, 1, 1, 1);
Vector pt = prevpt + up * 5;
cgi.R_DebugLine(prevpt, pt, 0, 0, 1, 1);
#endif
up.CrossProduct(v1, v2);
up.normalize();
// Calculate the first points
currpt1 = currpt + (up * scale);
currpt2 = currpt + (up * -scale);
if (!prevptvalid)
{
prevpt1 = prevpt + up * scale;
prevpt2 = prevpt + up * -scale;
prevptvalid = true;
}
#if 1
RenderSegment(currpt1, currpt2, prevpt1, prevpt2, modulate, beamshader, renderfx);
#endif
prevpt = currpt;
prevpt1 = currpt1;
prevpt2 = currpt2;
}
if (flags & BEAM_PERSIST_EFFECT)
CG_AddBeamsFromList(owner, beamshader);
}
static void CG_MultiBeamSubdivide
(
centity_t* cent
)
{
Vector pt1, pt2, pt3;
Vector out1, out2, out3, out4, out5, out6, out7, out8, out9;
centity_t* current;
ptctr = 0;
current = cent;
// Multibeam requires at least 3 points to start with
// Get pt1
if (current->currentState.tag_num == ENTITYNUM_NONE)
{
cgi.DPrintf("CG_MultiBeamSubdivide : Multi beam entity does not have a child\n");
return;
}
pt1 = current->lerpOrigin;
// Get pt2
current = &cg_entities[current->currentState.tag_num];
// Make sure that child is a multibeam
if (current->currentState.eType != ET_MULTIBEAM)
return;
if (current->currentState.tag_num == ENTITYNUM_NONE)
{
cgi.DPrintf("CG_MultiBeamSubdivide : Multi beam entity does not have a child\n");
return;
}
pt2 = current->lerpOrigin;
// Get pt3
current = &cg_entities[current->currentState.tag_num];
// Make sure that child is a multibeam
if (current->currentState.eType != ET_MULTIBEAM)
{
return;
}
if (current->currentState.tag_num == ENTITYNUM_NONE)
{
cgi.DPrintf("CG_MultiBeamSubdivide : Multi beam entity does not have a child\n");
return;
}
pt3 = current->lerpOrigin;
// First point into the subdivided points
subpoints[ptctr++] = pt1;
while (1)
{
// Do the subdivide
CG_Subdivide(pt1, pt2, pt3, out1, out2, out3);
CG_Subdivide(pt1, out1, out2, out4, out5, out6);
if ((ptctr + 4) > MAX_SUBPOINTS)
break;
// Save the points
subpoints[ptctr++] = out4;
subpoints[ptctr++] = out5;
subpoints[ptctr++] = out6;
subpoints[ptctr++] = out2;
// end condition
if ((current->currentState.tag_num == ENTITYNUM_NONE) || (!current->currentValid))
{
CG_Subdivide(out2, out3, pt3, out7, out8, out9);
subpoints[ptctr++] = out7;
subpoints[ptctr++] = out8;
subpoints[ptctr++] = out9;
subpoints[ptctr++] = pt3;
break;
}
// Advance to next ent
current = &cg_entities[current->currentState.tag_num];
if (!current->currentValid)
{
break;
}
// Advance the points down the line
pt1 = out2;
pt2 = pt3;
pt3 = current->lerpOrigin;
}
}
void CG_MultiBeam
(
centity_t* cent
)
{
Vector prevpt, currpt;
entityState_t* s1;
Vector p1, p2, p3, p4, v1, v2, up, currpt1, currpt2, prevpt1, prevpt2;
const char* beamshadername;
int beamshader;
byte modulate[4];
qboolean prevptvalid = false;
int i;
s1 = &cent->currentState;
// If this isn't the parent of the beam, then return
if (!s1->surfaces[0])
{
return;
}
// Subdivide up the segments
CG_MultiBeamSubdivide(cent);
// This is the top of the beam ent list, build up a renderer beam based on all the children
beamshadername = CG_ConfigString(CS_IMAGES + s1->surfaces[1]); // index for shader configstring
beamshader = cgi.R_RegisterShader(beamshadername);
//beamshader = cgi.R_RegisterShader( "<default>" );
for (i = 0; i < 4; i++)
modulate[i] = cent->color[i] * 255;
if (ptctr < 3)
{
return;
}
prevpt = subpoints[0];
prevptvalid = false;
for (i = 1; i < ptctr; i++)
{
currpt = subpoints[i];
// Generate the up vector
v1 = prevpt - cg.refdef.vieworg;
v2 = currpt - cg.refdef.vieworg;
#if 0
cgi.R_DebugLine(prevpt, currpt, 1, 1, 1, 1);
Vector pt = prevpt + up * 5;
cgi.R_DebugLine(prevpt, pt, 0, 0, 1, 1);
#endif
up.CrossProduct(v1, v2);
up.normalize();
// Calculate the first points
currpt1 = currpt + (up * s1->scale);
currpt2 = currpt + (up * -s1->scale);
if (!prevptvalid)
{
prevpt1 = prevpt + up * s1->scale;
prevpt2 = prevpt + up * -s1->scale;
prevptvalid = true;
}
RenderSegment(currpt1, currpt2, prevpt1, prevpt2, modulate, beamshader, s1->renderfx);
prevpt = currpt;
prevpt1 = currpt1;
prevpt2 = currpt2;
}
}
void CG_BuildRendererBeam
(
Vector start,
Vector end,
float angleVar,
int numSubdivisions,
byte color[4],
int beamshader,
float scale,
float overlap,
int owner,
float life,
int flags,
float startalpha,
float alphastep,
int renderfx
)
{
Vector p1, p2, v1, v2, dir, prevpt1, prevpt2, nextpt, mid, delta, up;
int i, ii, jj;
polyVert_t points[4];
float length;
int segnum = 0;
int beamnum = 0;
float alphafactor;
int picW;
// Create or increment the number of beams for this owner and check to
// see if we should add a new beam
if (flags & BEAM_PERSIST_EFFECT)
{
beamnum = CreateNewBeamEntity(owner, life);
if (beamnum < 0)
return;
}
// For debugging texture coords
//beamshader = cgi.R_RegisterShader( "<default>" );
picW = cgi.R_GetShaderWidth(beamshader);
// calcluate length of beam segment
delta = end - start;
length = delta.length();
length /= numSubdivisions;
// get the dir of beam
dir = delta;
dir.normalize();
// Calculate the first up vector
v1 = start - cg.refdef.vieworg;
v2 = end - cg.refdef.vieworg;
up.CrossProduct(v1, v2);
up.normalize();
// Calculate the first points
prevpt1 = start + (up * scale);
prevpt2 = start + (up * -scale);
p1 = start;
// go through and calculate each point of the beam and offset it by the anglevar
for (i = 1; i <= numSubdivisions; i++)
{
// Calculate the next point along the beam
p2 = start + (dir * i * length);
// Random variance on the next point ( except if it's the last )
if (i != numSubdivisions)
{
if (flags & BEAM_WAVE_EFFECT)
{
float phase = p2.x + p2.y;
p2.z += sin(phase + cg.time) * angleVar;
}
else if (flags & BEAM_USE_NOISE)
{
p2.x += cgi.R_Noise(p2.x, p2.y, p2.z, cg.time) * angleVar;
p2.y += cgi.R_Noise(p2.x, p2.y, p2.z, cg.time) * angleVar;
p2.z += cgi.R_Noise(p2.x, p2.y, p2.z, cg.time) * angleVar;
}
else
{
p2.x += Q_crandom(&seed) * angleVar;
p2.y += Q_crandom(&seed) * angleVar;
p2.z += Q_crandom(&seed) * angleVar;
}
}
// Create the up vec for the beam which is parallel to the viewplane
v1 = p1 - cg.refdef.vieworg;
v2 = p2 - cg.refdef.vieworg;
up.CrossProduct(v1, v2);
up.normalize();
// Build the quad
VectorMA(p2, scale, up, points[0].xyz);
VectorCopy(prevpt1, points[1].xyz);
VectorCopy(prevpt2, points[2].xyz);
VectorMA(p2, -scale, up, points[3].xyz);
if (flags & BEAM_TILESHADER) // Tile the shader across the beam
{
float startS = (length * (i - 1)) / (float)picW;
float endS = (length * (i)) / (float)picW;
points[0].st[0] = startS; points[0].st[1] = 1;
points[1].st[0] = endS; points[1].st[1] = 1;
points[2].st[0] = endS; points[2].st[1] = 0;
points[3].st[0] = startS; points[3].st[1] = 0;
}
else
{
points[0].st[0] = 1; points[0].st[1] = 1;
points[1].st[0] = 0; points[1].st[1] = 1;
points[2].st[0] = 0; points[2].st[1] = 0;
points[3].st[0] = 1; points[3].st[1] = 0;
}
if (!alphastep)
alphafactor = 1.0f;
else
alphafactor = startalpha + (alphastep * i);
// Set the color of the verts
for (ii = 0; ii < 4; ii++)
{
for (jj = 0; jj < 4; jj++)
{
points[ii].modulate[jj] = color[jj] * alphafactor;
}
}
if (flags & BEAM_PERSIST_EFFECT)
{
// Save the segment for backup for drawing faded out
AddBeamSegmentToList(owner, points, beamnum, segnum++, renderfx);
}
else
{
// Add it to the ref
cgi.R_AddPolyToScene(beamshader, 4, points, renderfx);
}
// Subtract off the overlap
if (overlap)
{
p2 = p2 + (dir * -overlap);
}
// Save off the last point to use as the first point on the next quad
VectorMA(p2, scale, up, prevpt1);
VectorMA(p2, -scale, up, prevpt2);
p1 = p2;
}
}
void CG_BuildRendererBeam_Fast
(
Vector start,
Vector end,
float angleVar,
int numSubdivisions,
byte color[4],
int beamshader,
float scale,
float overlap,
int owner,
float life,
int flags,
float startalpha,
float alphastep,
int renderfx
)
{
int ii, jj;
polyVert_t points[4];
int beamnum;
float alphafactor;
// Create or increment the number of beams for this owner and check to
// see if we should add a new beam
if (flags & BEAM_PERSIST_EFFECT)
{
beamnum = CreateNewBeamEntity(owner, life);
if (beamnum < 0)
return;
}
VectorMA(end, scale, cg.refdef.viewaxis[1], points[0].xyz);
VectorMA(start, scale, cg.refdef.viewaxis[1], points[1].xyz);
VectorMA(start, -scale, cg.refdef.viewaxis[1], points[2].xyz);
VectorMA(end, -scale, cg.refdef.viewaxis[1], points[3].xyz);
points[0].st[0] = 1.0;
points[0].st[1] = 1.0;
points[1].st[0] = 0.0;
points[1].st[1] = 1.0;
points[2].st[0] = 0.0;
points[2].st[1] = 0.0;
points[3].st[0] = 1.0;
points[3].st[1] = 0.0;
if (!alphastep)
{
for (ii = 0; ii < 4; ++ii)
{
for (jj = 0; jj < 4; ++jj) {
points[ii].modulate[jj] = color[jj];
}
}
}
else
{
alphafactor = startalpha + alphastep;
for (ii = 0; ii < 4; ++ii)
{
for (jj = 0; jj < 4; ++jj) {
points[ii].modulate[jj] = (int)((float)color[jj] * alphafactor);
}
}
}
if (flags & BEAM_PERSIST_EFFECT) {
AddBeamSegmentToList(owner, points, beamnum, 0, renderfx);
}
else {
cgi.R_AddPolyToScene(beamshader, 4, points, renderfx);
}
}
void CG_CreateModelBeam
(
beam_t* b,
vec3_t org,
vec3_t dist,
float total_length,
vec3_t ndir,
vec3_t left,
vec3_t up
)
{
dtiki_t* tiki;
vec3_t mins, maxs;
int single_beam_length;
refEntity_t ent;
int count;
int j;
float factor[3];
float t;
vec3_t angles;
int i;
// Find the length of a single beam
tiki = cgi.R_Model_GetHandle(b->hModel);
// Calculate the bounds of the model to get it's length
cgi.TIKI_CalculateBounds(tiki, 1.0, mins, maxs);
single_beam_length = maxs[0] - mins[0];
// Create the beam entity
memset(&ent, 0, sizeof(ent));
count = 0;
// Initialize the factors
for (j = 0; j < 3; j++)
factor[j] = 0.3f * crandom();
t = 0;
while (t >= 0 && t < 1)
{
float dot;
vec3_t pdir;
float delta;
vec3_t distance_point;
count++;
// Set the origin of the current beam using the last calculated org
VectorCopy(org, ent.origin);
// Advance the org one beam length in the new direction ( dist is the newly calculated direction )
for (j = 0; j < 3; j++)
org[j] += dist[j] * (single_beam_length - b->overlap);
// Offset the org by a random amount to simulate lightning
VectorMA(org, single_beam_length * factor[2], up, org);
VectorMA(org, single_beam_length * factor[1], left, org);
// Calculate (t) - how far this new point is along the overall distance
VectorSubtract(org, b->start, pdir);
dot = DotProduct(pdir, ndir);
t = dot / total_length;
// Calculate point at current distance along center beam
VectorMA(b->start, total_length * t, ndir, distance_point);
// Allow any variations
if (t > 0.1 && t < 0.9)
{
for (j = 0; j < 3; j++)
{
delta = org[j] - distance_point[j];
if (delta > b->max_offset)
{
org[j] = distance_point[j] + b->max_offset;
factor[j] = -0.3 * crandom();
}
else if (delta < -b->max_offset)
{
org[j] = distance_point[j] - b->max_offset;
factor[j] = 0.3 * crandom();
}
else
factor[j] = 0.3 * crandom();
}
}
else // Clamp to mins
{
for (j = 0; j < 3; j++)
{
delta = org[j] - distance_point[j];
if (delta > b->min_offset)
{
org[j] -= 0.4 * single_beam_length;
factor[j] = -0.2f;
}
else if (delta < -b->min_offset)
{
org[j] += 0.4 * single_beam_length;
factor[j] = 0.2f;
}
else
factor[j] = 0;
}
}
// Calculate the new dist vector so we can get pitch and yaw for this beam
VectorSubtract(org, ent.origin, dist);
// Set the pitch and the yaw based off this new vector
vectoangles(dist, angles);
// Fill in the ent fields
ent.hModel = b->hModel;
ent.scale = b->scale;
ent.renderfx = b->renderfx;
for (i = 0; i < 4; i++)
ent.shaderRGBA[i] = b->shaderRGBA[i];
VectorCopy(ent.origin, ent.oldorigin);
AnglesToAxis(angles, ent.axis);
// Add in this beam to the ref
cgi.R_AddRefEntityToScene(&ent, ENTITYNUM_NONE);
}
}
void CG_AddBeams(void)
{
int i, ii;
beam_t* b;
beam_t* bNext;
vec3_t delta;
vec3_t angles;
vec3_t forward, left, up;
float length;
byte color[4];
float fade;
for (i = 0, b = cl_active_beams; b; i++, b = bNext)
{
bNext = b->next;
// If no model is set or the endtime < current time remove the whole beam entity
if (!b->hModel || b->endtime < cg.time)
{
RemoveBeamList(b->entity);
b->entity = ENTITYNUM_NONE;
b->endtime = 0;
if (b->next) {
b->next->prev = b->prev;
}
if (b->prev) {
b->prev->next = b->next;
}
if (b == cl_active_beams) {
cl_active_beams = b->next;
}
if (cl_free_beams) {
cl_free_beams->prev = b;
}
b->next = cl_free_beams;
b->prev = 0;
cl_free_beams = b;
continue;
}
// Fade the beam based on it's life
fade = (float)(b->endtime - cg.time) / (float)b->life;
if (b->flags & BEAM_FADE)
{
for (ii = 0; ii < 4; ii++)
color[ii] = b->shaderRGBA[ii] * fade;
}
else
{
for (ii = 0; ii < 4; ii++)
color[ii] = b->shaderRGBA[ii];
}
// Check to see if the beam should be toggled
if (b->flags & BEAM_TOGGLE)
{
if (cg.time > b->toggletime)
{
b->active = !b->active;
if (b->flags & BEAM_RANDOM_TOGGLEDELAY)
b->toggletime = cg.time + random() * b->toggledelay;
else
b->toggletime = cg.time + b->toggledelay;
}
}
if (!b->active)
{
CG_AddBeamsFromList(b->entity, b->beamshader);
continue;
}
if ((b->flags & BEAM_PERSIST_EFFECT) && (b->update_time > cg.time))
{
CG_AddBeamsFromList(b->entity, b->beamshader);
continue;
}
b->update_time = cg.time + b->delay;
if (!b->active)
continue;
if (b->flags & BEAM_USEMODEL)
{
// Calculate the direction
VectorSubtract(b->start, b->end, delta);
// Calculate the beam length
length = VectorLength(delta);
// Get the perpendicular vectors to this vector
vectoangles(delta, angles);
AngleVectors(angles, forward, left, up);
CG_CreateModelBeam(b, b->start, delta, length, forward, left, up);
}
else
{
// Do a sphere effect
if (b->flags & BEAM_SPHERE_EFFECT)
{
int k;
// Calculate the direction
VectorSubtract(b->start, b->end, delta);
// Calculate the beam length
length = VectorLength(delta);
for (k = 0; k < b->numspherebeams; k++)
{
Vector offset(crandom(), crandom(), crandom());
Vector start(b->start + offset * b->sphereradius);
Vector end(b->start + offset * length);
CG_BuildRendererBeam(start,
end,
b->max_offset,
b->numSubdivisions,
color,
b->beamshader,
b->scale,
b->overlap,
b->entity,
b->life,
b->flags,
b->alpha,
b->alphastep,
b->renderfx
);
}
}
else if (b->flags & BEAM_INVERTED)
{
vec3_t vCurrStart, vCurrEnd;
vec3_t vDir;
float fLength;
// Calculate the direction
VectorSubtract(b->end, b->start, vDir);
VectorMA(b->start, 1.0 - fade, vDir, vCurrEnd);
fLength = VectorNormalize(vDir);
VectorMA(vCurrEnd, -b->toggledelay, vDir, vCurrStart);
CG_BuildRendererBeam(vCurrStart,
vCurrEnd,
b->max_offset,
b->numSubdivisions,
color,
b->beamshader,
b->scale,
b->overlap,
b->entity,
b->life,
b->flags,
b->alpha,
b->alphastep,
b->renderfx
);
}
else if (b->flags & BEAM_INVERTED_FAST)
{
vec3_t vCurrStart, vCurrEnd;
vec3_t vDir;
// Calculate the direction
VectorSubtract(b->end, b->start, vDir);
VectorMA(b->start, 1.0 - fade, vDir, vCurrEnd);
VectorNormalizeFast(vDir);
VectorMA(vCurrEnd, -b->toggledelay, vDir, vCurrStart);
CG_BuildRendererBeam_Fast(vCurrStart,
vCurrEnd,
b->max_offset,
b->numSubdivisions,
color,
b->beamshader,
b->scale,
b->overlap,
b->entity,
b->life,
b->flags,
b->alpha,
b->alphastep,
b->renderfx
);
}
else
{
//cgi.DPrintf( "%2f %2f %2f\n", b->start[0],b->start[1],b->start[2] );
CG_BuildRendererBeam(b->start,
b->end,
b->max_offset,
b->numSubdivisions,
color,
b->beamshader,
b->scale,
b->overlap,
b->entity,
b->life,
b->flags,
b->alpha,
b->alphastep,
b->renderfx
);
}
if (b->flags & BEAM_PERSIST_EFFECT)
CG_AddBeamsFromList(b->entity, b->beamshader);
}
}
}
void CG_CreateBeam
(
vec3_t start,
vec3_t dir,
int owner,
qhandle_t hModel,
float alpha,
float scale,
int flags,
float length,
int life,
qboolean create,
vec3_t endpointvec,
int min_offset,
int max_offset,
int overlap,
int numSubdivisions,
int delay,
const char* beamshadername,
float modulate[4],
int numspherebeams,
float sphereradius,
int toggledelay,
float endalpha,
int renderfx,
const char* name
)
{
int i;
beam_t* b;
vec3_t end;
trace_t trace;
// Check to see if endpoint is specified
if (endpointvec)
{
VectorCopy(endpointvec, end);
}
else
{
// Trace to find the endpoint with a shot
VectorMA(start, length, dir, end);
CG_Trace(&trace, start, vec3_origin, vec3_origin, end, 0, MASK_SHOT, false, true, "Create Beam");
VectorCopy(trace.endpos, end);
}
// If we aren't creating a beam, then search the beams for this one already active
if (!create)
{
for (i = 0, b = cl_active_beams; b; i++, b = b->next)
{
if (b->entity == owner)
{
if (name && b->name == name)
{
b->endtime = cg.time + life;
b->hModel = hModel;
b->scale = scale;
b->flags = flags;
b->overlap = overlap;
b->min_offset = min_offset;
b->max_offset = max_offset;
b->alpha = alpha;
b->beamshader = cgi.R_RegisterShader(beamshadername);
b->numSubdivisions = numSubdivisions;
b->delay = delay;
b->life = life;
b->numspherebeams = numspherebeams;
b->sphereradius = sphereradius;
b->renderfx = renderfx;
// take the alpha from the entity if less than 1, else grab it from the client commands version
if (alpha < 1)
b->shaderRGBA[3] = alpha * 255;
else
b->shaderRGBA[3] = modulate[3] * 255;
// Modulation based off the color
for (i = 0; i < 3; i++)
b->shaderRGBA[i] = modulate[i] * (float)b->shaderRGBA[3];
b->alphastep = ((float)(endalpha - alpha) / (float)b->numSubdivisions);
VectorCopy(start, b->start);
VectorCopy(end, b->end);
return;
}
}
}
}
// find a free beam
if (cl_free_beams)
{
b = cl_free_beams;
cl_free_beams = cl_free_beams->next;
if (cl_active_beams) {
cl_active_beams->prev = b;
}
b->next = cl_active_beams;
b->prev = 0;
cl_active_beams = b;
b->entity = owner;
b->endtime = cg.time + life;
b->hModel = hModel;
b->alpha = alpha;
b->scale = scale;
b->flags = flags;
b->overlap = overlap;
b->min_offset = min_offset;
b->max_offset = max_offset;
b->beamshader = cgi.R_RegisterShader(beamshadername);
b->numSubdivisions = numSubdivisions;
b->delay = delay;
b->update_time = 0;//cg.time + delay;
b->life = life;
b->numspherebeams = numspherebeams;
b->sphereradius = sphereradius;
b->active = true;
b->toggledelay = toggledelay;
b->renderfx = renderfx;
b->name = name;
// take the alpha from the entity if less than 1, else grab it from the client commands version
if (alpha < 1)
b->shaderRGBA[3] = alpha * 255;
else
b->shaderRGBA[3] = modulate[3] * 255;
// Modulation based off the color
for (i = 0; i < 3; i++)
b->shaderRGBA[i] = modulate[i] * (float)b->shaderRGBA[3];
b->alphastep = ((float)(endalpha - alpha) / (float)b->numSubdivisions);
VectorCopy(start, b->start);
VectorCopy(end, b->end);
return;
}
return;
}
void CG_KillBeams(int entity_number)
{
int i;
beam_t* b;
for (i = 0, b = cl_beams; i < MAX_BEAMS; i++, b++)
{
if (b->entity == entity_number)
{
b->entity = ENTITYNUM_NONE;
b->endtime = 0;
if (b->next) {
b->next->prev = b->prev;
}
if (b->prev) {
b->prev->next = b->next;
}
if (b == cl_active_beams) {
cl_active_beams = b->next;
}
if (cl_free_beams) {
cl_free_beams->prev = b;
}
b->next = cl_free_beams;
cl_free_beams = b;
b->prev = 0;
}
}
}
void CG_RestartBeams
(
int timedelta
)
{
int i;
beam_t* b;
for (i = 0, b = cl_beams; i < MAX_BEAMS; i++, b++)
{
if (b->active && (b->update_time > cg.time))
{
b->endtime -= timedelta;
b->update_time -= timedelta;
if (b->toggletime)
b->toggletime -= timedelta;
}
}
}
void CG_Rope
(
centity_t* cent
)
{
Vector prevpt, currpt;
entityState_t* s1;
Vector top, mid, bottom, up, v1, v2;
Vector currpt1, currpt2, prevpt1, prevpt2;
const char* beamshadername;
int beamshader;
byte modulate[4];
float picH, length, endT;
int i, j;
polyVert_t points[4];
s1 = &cent->currentState;
top = s1->origin2;
mid = cent->lerpOrigin;
bottom = cent->lerpOrigin;
bottom.z -= s1->alpha;
// This is the top of the beam ent list, build up a renderer beam based on all the children
beamshadername = CG_ConfigString(CS_IMAGES + s1->surfaces[0]); // index for shader configstring
beamshader = cgi.R_RegisterShader(beamshadername);
picH = cgi.R_GetShaderHeight(beamshader);
for (i = 0; i < 4; i++)
modulate[i] = cent->color[i] * 255;
// Generate the up vector
v1 = top - cg.refdef.vieworg;
v2 = bottom - cg.refdef.vieworg;
up.CrossProduct(v1, v2);
up.normalize();
// Set the color of the verts
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
points[i].modulate[j] = modulate[j];
}
}
// set the s coordinates
points[0].st[0] = 1;
points[1].st[0] = 1;
points[2].st[0] = 0;
points[3].st[0] = 0;
// Calculate the first points
prevpt1 = top + (up * s1->scale);
prevpt2 = top + (up * -s1->scale);
// draw the top section
currpt1 = mid + (up * s1->scale);
currpt2 = mid + (up * -s1->scale);
length = Vector(mid - top).length();
VectorCopy(currpt1, points[0].xyz);
VectorCopy(prevpt1, points[1].xyz);
VectorCopy(prevpt2, points[2].xyz);
VectorCopy(currpt2, points[3].xyz);
endT = length / picH;
points[0].st[1] = endT;
points[3].st[1] = endT;
points[1].st[1] = 0;
points[2].st[1] = 0;
// Add a segment to the list
cgi.R_AddPolyToScene(beamshader, 4, points, s1->renderfx);
if (s1->alpha > 0)
{
// draw the bottom section
prevpt1 = currpt1;
prevpt2 = currpt2;
currpt1 = bottom + (up * s1->scale);
currpt2 = bottom + (up * -s1->scale);
VectorCopy(currpt1, points[0].xyz);
VectorCopy(prevpt1, points[1].xyz);
VectorCopy(prevpt2, points[2].xyz);
VectorCopy(currpt2, points[3].xyz);
// add on the rest of the rope
length += s1->alpha;
// use previous T value for the start of this segment
points[1].st[1] = endT;
points[2].st[1] = endT;
endT = length / picH;
points[0].st[1] = endT;
points[3].st[1] = endT;
// Add a segment to the list
cgi.R_AddPolyToScene(beamshader, 4, points, s1->renderfx);
}
}
Reference in a new issue View git blame Copy permalink