private static void Test5_f()
{
entity_t p = Client.ViewEntity;
if (p == null)
{
return;
}
OpenTK.Vector3 org = p.origin;
for (int i = 0; i < Server.sv.edicts.Length; i++)
{
edict_t ed = Server.sv.edicts[i];
if (ed.free)
{
continue;
}
OpenTK.Vector3 vmin, vmax;
Mathlib.Copy(ref ed.v.absmax, out vmax);
Mathlib.Copy(ref ed.v.absmin, out vmin);
if (org.X >= vmin.X && org.Y >= vmin.Y && org.Z >= vmin.Z &&
org.X <= vmax.X && org.Y <= vmax.Y && org.Z <= vmax.Z)
{
Con.Print("{0}\n", i);
}
}
}
public static void Test5_f()
{
entity_t p = cl_entities[cl.viewentity];
if (p == null)
{
return;
}
OpenTK.Vector3 org = p.origin;
for (int i = 0; i < sv.edicts.Length; i++)
{
edict_t ed = sv.edicts[i];
if (ed.free)
{
continue;
}
OpenTK.Vector3 vmin, vmax;
Mathlib.Copy(ref ed.v.absmax, out vmax);
Mathlib.Copy(ref ed.v.absmin, out vmin);
if (org.X >= vmin.X && org.Y >= vmin.Y && org.Z >= vmin.Z &&
org.X <= vmax.X && org.Y <= vmax.Y && org.Z <= vmax.Z)
{
Con_Printf("{0}\n", i);
}
}
}
static void R_RenderWorld()
{
int i;
model.model_t clmodel;
if (btofpolys == null)
{
btofpolys = new btofpoly_t[MAX_BTOFPOLYS];
for (int kk = 0; kk < MAX_BTOFPOLYS; kk++)
{
btofpolys[kk] = new btofpoly_t();
}
pbtofpolys = btofpolys;
}
currententity = client.cl_entities[0];
mathlib.VectorCopy(r_origin, ref modelorg);
clmodel = currententity.model;
r_pcurrentvertbase = clmodel.vertexes;
R_RecursiveWorldNode(clmodel.nodes[0], 15);
// if the driver wants the polygons back to front, play the visible ones back
// in that order
if (r_worldpolysbacktofront)
{
for (i = numbtofpolys - 1; i >= 0; i--)
{
R_RenderPoly(btofpolys[i].psurf, btofpolys[i].clipflags);
}
}
}
/// <summary>
/// R_StoreEfrags
/// FIXME: a lot of this goes away with edge-based
/// </summary>
static void StoreEfrags(efrag_t ef)
{
while (ef != null)
{
entity_t pent = ef.entity;
model_t clmodel = pent.model;
switch (clmodel.type)
{
case modtype_t.mod_alias:
case modtype_t.mod_brush:
case modtype_t.mod_sprite:
if ((pent.visframe != _FrameCount) && (Client.NumVisEdicts < Client.MAX_VISEDICTS))
{
Client.VisEdicts[Client.NumVisEdicts++] = pent;
// mark that we've recorded this entity for this frame
pent.visframe = _FrameCount;
}
ef = ef.leafnext;
break;
default:
Sys.Error("R_StoreEfrags: Bad entity type {0}\n", clmodel.type);
break;
}
}
}
public void R_RotateForEntity(entity_t e)
{
GL.Translate(e.origin[0], e.origin[1], e.origin[2]);
GL.Rotate(e.angles[1], 0, 0, 1);
GL.Rotate(-e.angles[0], 0, 1, 0);
GL.Rotate(-e.angles[2], 1, 0, 0);
}
public static void R_StoreEfrags(efrag_t ef)
{
while (ef != null)
{
entity_t pent = ef.entity;
model_t clmodel = pent.model;
switch (clmodel.type)
{
case modtype_t.mod_alias:
case modtype_t.mod_brush:
case modtype_t.mod_sprite:
if ((pent.visframe != r_framecount) && (cl_numvisedicts < q_shared.MAX_VISEDICTS))
{
cl_visedicts[cl_numvisedicts++] = pent;
// mark that we've recorded this entity for this frame
pent.visframe = r_framecount;
}
ef = ef.leafnext;
break;
default:
Sys_Error("R_StoreEfrags: Bad entity type {0}\n", clmodel.type);
break;
}
}
}
static void V_BoundOffsets()
{
entity_t ent = cl_entities[cl.viewentity];
// absolutely bound refresh reletive to entity clipping hull
// so the view can never be inside a solid wall
refdef_t rdef = r_refdef;
if (rdef.vieworg.X < ent.origin.X - 14)
{
rdef.vieworg.X = ent.origin.X - 14;
}
else if (rdef.vieworg.X > ent.origin.X + 14)
{
rdef.vieworg.X = ent.origin.X + 14;
}
if (rdef.vieworg.Y < ent.origin.Y - 14)
{
rdef.vieworg.Y = ent.origin.Y - 14;
}
else if (rdef.vieworg.Y > ent.origin.Y + 14)
{
rdef.vieworg.Y = ent.origin.Y + 14;
}
if (rdef.vieworg.Z < ent.origin.Z - 22)
{
rdef.vieworg.Z = ent.origin.Z - 22;
}
else if (rdef.vieworg.Z > ent.origin.Z + 30)
{
rdef.vieworg.Z = ent.origin.Z + 30;
}
}
/*
===========
R_AddEfrags
===========
*/
public static void R_AddEfrags(entity_t ent)
{
model.model_t entmodel;
int i;
if (ent.model == null)
return;
if (ent == client.cl_entities[0])
return; // never add the world
r_addent = ent;
lastlink = null;
r_pefragtopnode = null;
entmodel = ent.model;
for (i = 0; i < 3; i++)
{
r_emins[i] = ent.origin[i] + entmodel.mins[i];
r_emaxs[i] = ent.origin[i] + entmodel.maxs[i];
}
R_SplitEntityOnNode(client.cl.worldmodel.nodes[0]);
ent.topnode = r_pefragtopnode;
}
/*
================
R_RemoveEfrags
Call when removing an object from the world or moving it to another position
================
*/
public static void R_RemoveEfrags(entity_t ent)
{
efrag_t ef, old, walk, prev;
ef = ent.efrag;
while (ef != null)
{
prev = ef.leaf.efrags;
while (true)
{
walk = prev;
if (walk == null)
break;
if (walk == ef)
{ // remove this fragment
prev = ef.leafnext;
break;
}
else
prev = walk.leafnext;
}
old = ef;
ef = ef.entnext;
// put it on the free list
old.entnext = client.cl.free_efrags;
client.cl.free_efrags = old;
}
ent.efrag = null;
}
/*
* ===========
* R_AddEfrags
* ===========
*/
public static void R_AddEfrags(entity_t ent)
{
model.model_t entmodel;
int i;
if (ent.model == null)
{
return;
}
if (ent == client.cl_entities[0])
{
return; // never add the world
}
r_addent = ent;
lastlink = null;
r_pefragtopnode = null;
entmodel = ent.model;
for (i = 0; i < 3; i++)
{
r_emins[i] = ent.origin[i] + entmodel.mins[i];
r_emaxs[i] = ent.origin[i] + entmodel.maxs[i];
}
R_SplitEntityOnNode(client.cl.worldmodel.nodes[0]);
ent.topnode = r_pefragtopnode;
}
// V_BoundOffsets
private static void BoundOffsets()
{
entity_t ent = client.ViewEntity;
// absolutely bound refresh reletive to entity clipping hull
// so the view can never be inside a solid wall
refdef_t rdef = render.RefDef;
if (rdef.vieworg.X < ent.origin.X - 14)
{
rdef.vieworg.X = ent.origin.X - 14;
}
else if (rdef.vieworg.X > ent.origin.X + 14)
{
rdef.vieworg.X = ent.origin.X + 14;
}
if (rdef.vieworg.Y < ent.origin.Y - 14)
{
rdef.vieworg.Y = ent.origin.Y - 14;
}
else if (rdef.vieworg.Y > ent.origin.Y + 14)
{
rdef.vieworg.Y = ent.origin.Y + 14;
}
if (rdef.vieworg.Z < ent.origin.Z - 22)
{
rdef.vieworg.Z = ent.origin.Z - 22;
}
else if (rdef.vieworg.Z > ent.origin.Z + 30)
{
rdef.vieworg.Z = ent.origin.Z + 30;
}
}
public static void R_RotateForEntity(entity_t e)
{
GL.Translate(e.origin);
GL.Rotate(e.angles.Y, 0, 0, 1);
GL.Rotate(-e.angles.X, 0, 1, 0);
GL.Rotate(e.angles.Z, 1, 0, 0);
}
public static void R_EntityParticles(entity_t ent)
{
int count;
int i;
draw.particle_t p;
double angle;
double sr, sp, sy, cr, cp, cy;
double[] forward = new double[3];
double dist;
dist = 64;
count = 50;
if (avelocities[0, 0] == 0)
{
for (i = 0; i < NUMVERTEXNORMALS * 3; i++)
{
avelocities[0, i] = (helper.rand() & 255) * 0.01;
}
}
for (i = 0; i < NUMVERTEXNORMALS; i++)
{
angle = client.cl.time * avelocities[i, 0];
sy = Math.Sin(angle);
cy = Math.Cos(angle);
angle = client.cl.time * avelocities[i, 1];
sp = Math.Sin(angle);
cp = Math.Cos(angle);
angle = client.cl.time * avelocities[i, 2];
sr = Math.Sin(angle);
cr = Math.Cos(angle);
forward[0] = cp * cy;
forward[1] = cp * sy;
forward[2] = -sp;
if (free_particles == null)
{
return;
}
p = free_particles;
free_particles = p.next;
p.next = active_particles;
active_particles = p;
p.die = client.cl.time + 0.01;
p.color = 0x6f;
p.type = draw.ptype_t.pt_explode;
p.org[0] = ent.origin[0] + r_avertexnormals[i][0] * dist + forward[0] * beamlength;
p.org[1] = ent.origin[1] + r_avertexnormals[i][1] * dist + forward[1] * beamlength;
p.org[2] = ent.origin[2] + r_avertexnormals[i][2] * dist + forward[2] * beamlength;
}
}
// CL_Init
public static void Init()
{
InitInput();
InitTempEntities();
if (_Name == null)
{
_Name = new Cvar("_cl_name", "player", true);
_Color = new Cvar("_cl_color", "0", true);
_ShowNet = new Cvar("cl_shownet", "0"); // can be 0, 1, or 2
_NoLerp = new Cvar("cl_nolerp", "0");
_LookSpring = new Cvar("lookspring", "0", true);
_LookStrafe = new Cvar("lookstrafe", "0", true);
_Sensitivity = new Cvar("sensitivity", "3", true);
_MPitch = new Cvar("m_pitch", "0.022", true);
_MYaw = new Cvar("m_yaw", "0.022", true);
_MForward = new Cvar("m_forward", "1", true);
_MSide = new Cvar("m_side", "0.8", true);
_UpSpeed = new Cvar("cl_upspeed", "200");
_ForwardSpeed = new Cvar("cl_forwardspeed", "200", true);
_BackSpeed = new Cvar("cl_backspeed", "200", true);
_SideSpeed = new Cvar("cl_sidespeed", "350");
_MoveSpeedKey = new Cvar("cl_movespeedkey", "2.0");
_YawSpeed = new Cvar("cl_yawspeed", "140");
_PitchSpeed = new Cvar("cl_pitchspeed", "150");
_AngleSpeedKey = new Cvar("cl_anglespeedkey", "1.5");
}
for (int i = 0; i < _EFrags.Length; i++)
{
_EFrags[i] = new efrag_t();
}
for (int i = 0; i < _Entities.Length; i++)
{
_Entities[i] = new entity_t();
}
for (int i = 0; i < _StaticEntities.Length; i++)
{
_StaticEntities[i] = new entity_t();
}
for (int i = 0; i < _DLights.Length; i++)
{
_DLights[i] = new dlight_t();
}
//
// register our commands
//
Cmd.Add("entities", PrintEntities_f);
Cmd.Add("disconnect", Disconnect_f);
Cmd.Add("record", Record_f);
Cmd.Add("stop", Stop_f);
Cmd.Add("playdemo", PlayDemo_f);
Cmd.Add("timedemo", TimeDemo_f);
}
/*
* ===================== V_AddEntity
*
* =====================
*/
public static void AddEntity(entity_t ent)
{
if (V.r_numentities >= Defines.MAX_ENTITIES)
{
return;
}
V.r_entities[V.r_numentities++].set(ent);
}
public static void CL_Init()
{
CL_InitInput();
CL_InitTEnts();
cl_name = new cvar_t("_cl_name", "player", true);
cl_color = new cvar_t("_cl_color", "0", true);
cl_shownet = new cvar_t("cl_shownet", "0"); // can be 0, 1, or 2
cl_nolerp = new cvar_t("cl_nolerp", "0");
lookspring = new cvar_t("lookspring", "0", true);
lookstrafe = new cvar_t("lookstrafe", "0", true);
sensitivity = new cvar_t("sensitivity", "3", true);
m_pitch = new cvar_t("m_pitch", "0.022", true);
m_yaw = new cvar_t("m_yaw", "0.022", true);
m_forward = new cvar_t("m_forward", "1", true);
m_side = new cvar_t("m_side", "0.8", true);
cl_upspeed = new cvar_t("cl_upspeed", "200");
cl_forwardspeed = new cvar_t("cl_forwardspeed", "200", true);
cl_backspeed = new cvar_t("cl_backspeed", "200", true);
cl_sidespeed = new cvar_t("cl_sidespeed", "350");
cl_movespeedkey = new cvar_t("cl_movespeedkey", "2.0");
cl_yawspeed = new cvar_t("cl_yawspeed", "140");
cl_pitchspeed = new cvar_t("cl_pitchspeed", "150");
cl_anglespeedkey = new cvar_t("cl_anglespeedkey", "1.5");
for (int i = 0; i < cl_efrags.Length; i++)
{
cl_efrags[i] = new efrag_t();
}
for (int i = 0; i < cl_entities.Length; i++)
{
cl_entities[i] = new entity_t();
}
for (int i = 0; i < cl_static_entities.Length; i++)
{
cl_static_entities[i] = new entity_t();
}
for (int i = 0; i < cl_dlights.Length; i++)
{
cl_dlights[i] = new dlight_t();
}
//
// register our commands
//
Cmd_AddCommand("entities", CL_PrintEntities_f);
Cmd_AddCommand("disconnect", CL_Disconnect_f);
Cmd_AddCommand("record", CL_Record_f);
Cmd_AddCommand("stop", CL_Stop_f);
Cmd_AddCommand("playdemo", CL_PlayDemo_f);
Cmd_AddCommand("timedemo", CL_TimeDemo_f);
}
public virtual void R_DrawSpriteModel(entity_t e)
{
var alpha = 1F;
qfiles.dsprframe_t frame;
qfiles.dsprite_t psprite;
psprite = (qfiles.dsprite_t)currentmodel.extradata;
e.frame %= psprite.numframes;
frame = psprite.frames[e.frame];
if ((e.flags & Defines.RF_TRANSLUCENT) != 0)
{
alpha = e.alpha;
}
if (alpha != 1F)
{
GL.Enable(EnableCap.Blend);
}
GL.Color4(1, 1, 1, alpha);
GL_Bind(currentmodel.skins[e.frame].texnum);
GL_TexEnv(( Int32 )All.Modulate);
if (alpha == 1)
{
GL.Enable(EnableCap.AlphaTest);
}
else
{
GL.Disable(EnableCap.AlphaTest);
}
GL.Begin(PrimitiveType.Quads);
GL.TexCoord2(0, 1);
Math3D.VectorMA(e.origin, -frame.origin_y, vup, point);
Math3D.VectorMA(point, -frame.origin_x, vright, point);
GL.Vertex3(point[0], point[1], point[2]);
GL.TexCoord2(0, 0);
Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point);
Math3D.VectorMA(point, -frame.origin_x, vright, point);
GL.Vertex3(point[0], point[1], point[2]);
GL.TexCoord2(1, 0);
Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point);
Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point);
GL.Vertex3(point[0], point[1], point[2]);
GL.TexCoord2(1, 1);
Math3D.VectorMA(e.origin, -frame.origin_y, vup, point);
Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point);
GL.Vertex3(point[0], point[1], point[2]);
GL.End();
GL.Disable(EnableCap.AlphaTest);
GL_TexEnv(( Int32 )All.Replace);
if (alpha != 1F)
{
GL.Disable(EnableCap.Blend);
}
GL.Color4(1, 1, 1, 1);
}
private void TestModel()
{
refdef_t refdef = new refdef_t();
refdef.x = viddef.GetWidth() / 2;
refdef.y = viddef.GetHeight() / 2 - 72;
refdef.width = 144 * 2;
refdef.height = 168 * 2;
refdef.fov_x = 40;
refdef.fov_y = Math3D.CalcFov(refdef.fov_x, refdef.width, refdef.height);
refdef.time = 1F * 0.001F;
entity_t entity = new entity_t();
string modelName = "players/female/tris.md2";
string modelSkin = "players/female/athena.pcx";
string modelImage = "/players/female/athena_i.pcx";
string modelImage1 = "/players/female/brianna_i.pcx";
string modelImage2 = "/players/female/cobalt_i.pcx";
string modelImage3 = "/players/female/lotus_i.pcx";
entity.model = re.RegisterModel(modelName);
DrawString(refdef.x, refdef.y - 20, (entity.model != null) ? modelName : "DEBUG: NullModel");
entity.skin = re.RegisterSkin(modelSkin);
entity.flags = Defines.RF_FULLBRIGHT;
entity.origin[0] = 80;
entity.origin[1] = 0;
entity.origin[2] = 0;
Math3D.VectorCopy(entity.origin, entity.oldorigin);
entity.frame = (framecount / 3) % ((qfiles.dmdl_t)entity.model.extradata).num_frames;
entity.oldframe = 0;
entity.backlerp = 0F;
yaw += KBD.mx;
KBD.mx = 0;
if (yaw > 360)
{
yaw -= 360;
}
if (yaw < 0)
{
yaw += 360;
}
entity.angles[1] = yaw;
refdef.areabits = null;
refdef.num_entities = 1;
refdef.entities = new entity_t[] { entity };
refdef.lightstyles = null;
refdef.rdflags = Defines.RDF_NOWORLDMODEL;
M_DrawTextBox((int)((refdef.x) * (320F / viddef.GetWidth()) - 8), (int)((viddef.GetHeight() / 2) * (240F / viddef.GetHeight()) - 77), refdef.width / 8, refdef.height / 8);
refdef.height += 4;
re.RenderFrame(refdef);
re.DrawPic(refdef.x - 80, refdef.y, modelImage);
re.DrawPic(refdef.x - 80, refdef.y + 47, modelImage1);
re.DrawPic(refdef.x - 80, refdef.y + 94, modelImage2);
re.DrawPic(refdef.x - 80, refdef.y + 141, modelImage3);
}
public virtual void R_DrawBeam(entity_t e)
{
oldorigin[0] = e.oldorigin[0];
oldorigin[1] = e.oldorigin[1];
oldorigin[2] = e.oldorigin[2];
origin[0] = e.origin[0];
origin[1] = e.origin[1];
origin[2] = e.origin[2];
normalized_direction[0] = direction[0] = oldorigin[0] - origin[0];
normalized_direction[1] = direction[1] = oldorigin[1] - origin[1];
normalized_direction[2] = direction[2] = oldorigin[2] - origin[2];
if (Math3D.VectorNormalize(normalized_direction) == 0F)
{
return;
}
Math3D.PerpendicularVector(perpvec, normalized_direction);
Math3D.VectorScale(perpvec, e.frame / 2, perpvec);
for (var i = 0; i < 6; i++)
{
Math3D.RotatePointAroundVector(start_points[i], normalized_direction, perpvec, (360F / NUM_BEAM_SEGS) * i);
Math3D.VectorAdd(start_points[i], origin, start_points[i]);
Math3D.VectorAdd(start_points[i], direction, end_points[i]);
}
GL.Disable(EnableCap.Texture2D);
GL.Enable(EnableCap.Blend);
GL.DepthMask(false);
Single r = (d_8to24table[e.skinnum & 0xFF]) & 0xFF;
Single g = (d_8to24table[e.skinnum & 0xFF] >> 8) & 0xFF;
Single b = (d_8to24table[e.skinnum & 0xFF] >> 16) & 0xFF;
r *= 1 / 255F;
g *= 1 / 255F;
b *= 1 / 255F;
GL.Color4(r, g, b, e.alpha);
GL.Begin(PrimitiveType.TriangleStrip);
Single[] v;
for (var i = 0; i < NUM_BEAM_SEGS; i++)
{
v = start_points[i];
GL.Vertex3(v[0], v[1], v[2]);
v = end_points[i];
GL.Vertex3(v[0], v[1], v[2]);
v = start_points[(i + 1) % NUM_BEAM_SEGS];
GL.Vertex3(v[0], v[1], v[2]);
v = end_points[(i + 1) % NUM_BEAM_SEGS];
GL.Vertex3(v[0], v[1], v[2]);
}
GL.End();
GL.Enable(EnableCap.Texture2D);
GL.Disable(EnableCap.Blend);
GL.DepthMask(true);
}
/// <summary>
/// CL_ParseBaseline
/// </summary>
/// <param name="ent"></param>
static void ParseBaseline(entity_t ent)
{
ent.baseline.modelindex = Net.Reader.ReadByte();
ent.baseline.frame = Net.Reader.ReadByte();
ent.baseline.colormap = Net.Reader.ReadByte();
ent.baseline.skin = Net.Reader.ReadByte();
ent.baseline.origin.x = Net.Reader.ReadCoord();
ent.baseline.angles.x = Net.Reader.ReadAngle();
ent.baseline.origin.y = Net.Reader.ReadCoord();
ent.baseline.angles.y = Net.Reader.ReadAngle();
ent.baseline.origin.z = Net.Reader.ReadCoord();
ent.baseline.angles.z = Net.Reader.ReadAngle();
}
static void CL_ParseBaseline(entity_t ent)
{
ent.baseline.modelindex = Reader.MSG_ReadByte();
ent.baseline.frame = Reader.MSG_ReadByte();
ent.baseline.colormap = Reader.MSG_ReadByte();
ent.baseline.skin = Reader.MSG_ReadByte();
ent.baseline.origin.x = Reader.MSG_ReadCoord();
ent.baseline.angles.x = Reader.MSG_ReadAngle();
ent.baseline.origin.y = Reader.MSG_ReadCoord();
ent.baseline.angles.y = Reader.MSG_ReadAngle();
ent.baseline.origin.z = Reader.MSG_ReadCoord();
ent.baseline.angles.z = Reader.MSG_ReadAngle();
}
// CL_PrintEntities_f
static void PrintEntities_f()
{
for (int i = 0; i < _State.num_entities; i++)
{
entity_t ent = _Entities[i];
Con.Print("{0:d3}:", i);
if (ent.model == null)
{
Con.Print("EMPTY\n");
continue;
}
Con.Print("{0}:{1:d2} ({2}) [{3}]\n", ent.model.name, ent.frame, ent.origin, ent.angles);
}
}
public static void R_DrawSpriteModel(entity_t e)
{
// don't even bother culling, because it's just a single
// polygon without a surface cache
mspriteframe_t frame = R_GetSpriteFrame(e);
msprite_t psprite = (msprite_t)e.model.cache.data;
Vector3 v_forward, right, up;
if (psprite.type == q_shared.SPR_ORIENTED)
{
// bullet marks on walls
Mathlib.AngleVectors(ref e.angles, out v_forward, out right, out up); // Uze: changed from _CurrentEntity to e
}
else
{ // normal sprite
up = vup; // vup;
right = vright; // vright;
}
GL.Color3(1f, 1, 1);
GL_DisableMultitexture();
GL_Bind(frame.gl_texturenum);
GL.Enable(EnableCap.AlphaTest);
GL.Begin(BeginMode.Quads);
GL.TexCoord2(0f, 1);
Vector3 point = e.origin + up * frame.down + right * frame.left;
GL.Vertex3(point);
GL.TexCoord2(0f, 0);
point = e.origin + up * frame.up + right * frame.left;
GL.Vertex3(point);
GL.TexCoord2(1f, 0);
point = e.origin + up * frame.up + right * frame.right;
GL.Vertex3(point);
GL.TexCoord2(1f, 1);
point = e.origin + up * frame.down + right * frame.right;
GL.Vertex3(point);
GL.End();
GL.Disable(EnableCap.AlphaTest);
}
public void Add(entity_t entity, GameObject entityInstance)
{
m_objects.Add(entityInstance);
var targetname = entity.targetname;
if (targetname != -1)
{
if (m_targets.ContainsKey(targetname))
{
Debug.LogWarning("Duplicate target name: " + targetname + " " + m_targets[targetname]);
}
m_targets[targetname] = entityInstance;
}
}
private void TestModel()
{
refdef_t refdef = new refdef_t();
refdef.x = 0;
refdef.y = 0;
refdef.width = viddef.GetWidth();
refdef.height = viddef.GetHeight();
refdef.fov_x = fov_x;
refdef.fov_y = fov_y;
refdef.time = 1F * 0.001F;
if (models == null)
{
models = new entity_t[12];
entity_t m = null;
for (int i = 0; i < models.length; i++)
{
m = GetModel(skinNames[i % skinNames.length]);
m.origin[0] += 30 * i;
m.origin[1] += ((i % 4)) * 30 - 20;
models[i] = m;
}
}
yaw = Time() * 0.1F;
if (yaw > 360)
{
yaw -= 360;
}
if (yaw < 0)
{
yaw += 360;
}
for (int i = 0; i < models.length; i++)
{
models[i].frame = (Time() / 70) % models[i].model.numframes;
models[i].angles[1] = yaw;
models[i].origin[0] += KBD.my;
models[i].origin[1] += KBD.mx;
}
refdef.areabits = null;
refdef.num_entities = models.length;
refdef.entities = models;
refdef.lightstyles = null;
refdef.rdflags = Defines.RDF_NOWORLDMODEL;
re.RenderFrame(refdef);
}
static object _LastObj; // see comments
/// <summary>
/// R_AddEfrags
/// </summary>
public static void AddEfrags(entity_t ent)
{
if (ent.model == null)
return;
_AddEnt = ent;
_LastObj = ent; // lastlink = &ent->efrag;
_EfragTopNode = null;
model_t entmodel = ent.model;
_EMins = ent.origin + entmodel.mins;
_EMaxs = ent.origin + entmodel.maxs;
SplitEntityOnNode(Client.cl.worldmodel.nodes[0]);
ent.topnode = _EfragTopNode;
}
public override void R_DrawWorld( )
{
entity_t ent = new entity_t();
ent.frame = ( Int32 )(r_newrefdef.time * 2);
currententity = ent;
if (r_drawworld.value == 0)
{
return;
}
if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0)
{
return;
}
currentmodel = r_worldmodel;
Math3D.VectorCopy(r_newrefdef.vieworg, modelorg);
gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
GL.Color3(1, 1, 1);
gl_lms.ClearLightmapSurfaces();
R_ClearSkyBox();
if (qglMTexCoord2fSGIS)
{
GL_EnableMultitexture(true);
GL_SelectTexture(TextureUnit.Texture0);
GL_TexEnv(( Int32 )All.Replace);
GL_SelectTexture(TextureUnit.Texture1);
if (gl_lightmap.value != 0)
{
GL_TexEnv(( Int32 )All.Replace);
}
else
{
GL_TexEnv(( Int32 )All.Modulate);
}
R_RecursiveWorldNode(r_worldmodel.nodes[0]);
GL_EnableMultitexture(false);
}
else
{
R_RecursiveWorldNode(r_worldmodel.nodes[0]);
}
DrawTextureChains();
R_BlendLightmaps();
R_DrawSkyBox();
R_DrawTriangleOutlines();
}
// V_CalcIntermissionRefdef
private static void CalcIntermissionRefDef()
{
// ent is the player model (visible when out of body)
entity_t ent = client.ViewEntity;
// view is the weapon model (only visible from inside body)
entity_t view = client.ViewEnt;
refdef_t rdef = render.RefDef;
rdef.vieworg = ent.origin;
rdef.viewangles = ent.angles;
view.model = null;
// allways idle in intermission
AddIdle(1);
}
static entity_t CreateEntity(Dictionary <string, string> dict)
{
string classname;
if (!dict.TryGetValue(kEntityClassname, out classname))
{
throw new ArgumentException("Can't find required '" + kEntityClassname + "' key");
}
Assembly assembly = typeof(entity_t).Assembly;
Type type = assembly.GetType(classname + "_t");
if (type == null)
{
throw new ArgumentException("Can't find class: " + classname);
}
if (!type.IsSubclassOf(typeof(entity_t)))
{
throw new ArgumentException("Type doesn't extend " + typeof(entity_t).Name + ": " + type);
}
entity_t entity = Activator.CreateInstance(type) as entity_t;
Dictionary <string, FieldInfo> fields = ReflectionUtils.ListFields(entity);
foreach (var entry in dict)
{
string key = entry.Key;
string value = entry.Value;
if (key == kEntityClassname)
{
continue;
}
FieldInfo field;
if (!fields.TryGetValue(key, out field))
{
throw new Exception("Can't find field '" + key + "' in type '" + type + "'");
}
SetFieldValue(field, entity, value);
}
return(entity);
}
static void V_CalcIntermissionRefdef()
{
// ent is the player model (visible when out of body)
entity_t ent = cl_entities[cl.viewentity];
// view is the weapon model (only visible from inside body)
entity_t view = cl.viewent;
refdef_t rdef = r_refdef;
rdef.vieworg = ent.origin;
rdef.viewangles = ent.angles;
view.model = null;
// allways idle in intermission
V_AddIdle(1);
}
public override void R_DrawWorld( )
{
if (r_drawworld.value == 0)
{
return;
}
if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0)
{
return;
}
currentmodel = r_worldmodel;
Math3D.VectorCopy(r_newrefdef.vieworg, modelorg);
entity_t ent = worldEntity;
ent.Clear();
ent.frame = ( Int32 )(r_newrefdef.time * 2);
currententity = ent;
gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
GL.Color3(1, 1, 1);
R_ClearSkyBox();
GL_EnableMultitexture(true);
GL_SelectTexture(TextureUnit.Texture0);
GL_TexEnv(( Int32 )All.Replace);
GL.InterleavedArrays(InterleavedArrayFormat.T2fV3f, glpoly_t.BYTE_STRIDE, globalPolygonInterleavedBuf.Array);
GL_SelectTexture(TextureUnit.Texture1);
new Pinnable(globalPolygonTexCoord1Buf, (ptr) =>
{
GL.TexCoordPointer(2, TexCoordPointerType.Float, glpoly_t.BYTE_STRIDE, ptr);
});
GL.EnableClientState(ArrayCap.TextureCoordArray);
if (gl_lightmap.value != 0)
{
GL_TexEnv(( Int32 )All.Replace);
}
else
{
GL_TexEnv(( Int32 )All.Modulate);
}
R_RecursiveWorldNode(r_worldmodel.nodes[0]);
GL.ClientActiveTexture(TextureUnit.Texture1);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL_EnableMultitexture(false);
DrawTextureChains();
R_DrawSkyBox();
R_DrawTriangleOutlines();
}
private void TestSprites()
{
if (loading)
{
re.DrawPic(viddef.GetWidth() / 2 - 50, viddef.GetHeight() / 2, "loading");
string name = sprites[spriteCount];
DrawString(viddef.GetWidth() / 2 - 50, viddef.GetHeight() / 2 + 50, name);
re.RegisterModel(name);
loading = ++spriteCount < sprites.Length;
return;
}
refdef_t refdef = new refdef_t();
refdef.x = viddef.GetWidth() / 2;
refdef.y = viddef.GetHeight() / 2 - 72;
refdef.width = 144 * 2;
refdef.height = 168 * 2;
refdef.fov_x = 40;
refdef.fov_y = Math3D.CalcFov(refdef.fov_x, refdef.width, refdef.height);
refdef.time = 1F * 0.001F;
entity_t entity = new entity_t();
string modelName = sprites[(framecount / 30) % sprites.Length];
DrawString(refdef.x, refdef.y - 20, modelName);
entity.model = re.RegisterModel(modelName);
entity.flags = Defines.RF_FULLBRIGHT;
entity.origin[0] = 80 - (framecount % 200) + 200;
entity.origin[1] = 0 + (float)(40 * Math.Sin(Math.ToRadians(framecount)));
entity.origin[2] = 0 + 20;
Math3D.VectorCopy(entity.origin, entity.oldorigin);
entity.frame = framecount / 2;
entity.oldframe = 0;
entity.backlerp = 0F;
refdef.areabits = null;
refdef.num_entities = 1;
refdef.entities = new entity_t {
entity
};
refdef.lightstyles = null;
refdef.rdflags = Defines.RDF_NOWORLDMODEL;
M_DrawTextBox((int)((refdef.x) * (320F / viddef.GetWidth()) - 8), (int)((viddef.GetHeight() / 2) * (240F / viddef.GetHeight()) - 77), refdef.width / 8, refdef.height / 8);
refdef.height += 4;
re.RenderFrame(refdef);
}
public static void R_EntityParticles(entity_t ent)
{
int count;
int i;
draw.particle_t p;
double angle;
double sr, sp, sy, cr, cp, cy;
double[] forward = new double[3] {0, 0, 0};
double dist;
dist = 64;
count = 50;
if (avelocities[0,0] == 0)
{
for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
avelocities[0, i] = (helper.rand() & 255) * 0.01;
}
for (i=0 ; i<NUMVERTEXNORMALS ; i++)
{
angle = client.cl.time * avelocities[i,0];
sy = Math.Sin(angle);
cy = Math.Cos(angle);
angle = client.cl.time * avelocities[i,1];
sp = Math.Sin(angle);
cp = Math.Cos(angle);
angle = client.cl.time * avelocities[i,2];
sr = Math.Sin(angle);
cr = Math.Cos(angle);
forward[0] = cp*cy;
forward[1] = cp*sy;
forward[2] = -sp;
if (free_particles == null)
return;
p = free_particles;
free_particles = p.next;
p.next = active_particles;
active_particles = p;
p.die = client.cl.time + 0.01;
p.color = 0x6f;
p.type = draw.ptype_t.pt_explode;
p.org[0] = ent.origin[0] + r_avertexnormals[i][0]*dist + forward[0]*beamlength;
p.org[1] = ent.origin[1] + r_avertexnormals[i][1]*dist + forward[1]*beamlength;
p.org[2] = ent.origin[2] + r_avertexnormals[i][2]*dist + forward[2]*beamlength;
}
}
static void R_RenderWorld()
{
int i;
model.model_t clmodel;
if (btofpolys == null)
{
btofpolys = new btofpoly_t[MAX_BTOFPOLYS];
for (int kk = 0; kk < MAX_BTOFPOLYS; kk++) btofpolys[kk] = new btofpoly_t();
pbtofpolys = btofpolys;
}
currententity = client.cl_entities[0];
mathlib.VectorCopy (r_origin, modelorg);
clmodel = currententity.model;
r_pcurrentvertbase = clmodel.vertexes;
R_RecursiveWorldNode (clmodel.nodes[0], 15);
// if the driver wants the polygons back to front, play the visible ones back
// in that order
if (r_worldpolysbacktofront)
{
for (i=numbtofpolys-1 ; i>=0 ; i--)
{
R_RenderPoly (btofpolys[i].psurf, btofpolys[i].clipflags);
}
}
}
