new waypointsprite system, onslaught not yet supported
[divverent/nexuiz.git] / data / qcsrc / client / waypointsprites.qc
1 vector project_3d_to_2d(vector vec)
2
3         vec = cs_project(vec);
4         if(cs_project_is_b0rked)
5         {
6                 vec_x += vid_width / 2;
7                 vec_y += vid_height / 2;
8         }
9         vec_x *= vid_conwidth / vid_width;
10         vec_y *= vid_conheight / vid_height;
11         return vec;
12 }
13
14 float waypointsprite_fadedistance;
15 float waypointsprite_normdistance;
16 float waypointsprite_minscale;
17 float waypointsprite_minalpha;
18 float waypointsprite_distancealphaexponent;
19 float waypointsprite_timealphaexponent;
20
21 .float rule;
22 .string netname; // primary picture
23 .string netname2; // secondary picture
24 .string netname3; // tertiary picture
25 .float team; // team that gets netname2
26 .float lifetime;
27 .float fadetime;
28 .float maxdistance;
29 .float hideflags;
30
31 vector SPRITE_SIZE = '128 32 0';
32 vector SPRITE_HOTSPOT = '64 32 0';
33
34 void drawrotpic(vector org, float rot, string pic, vector sz, vector hotspot, vector rgb, float a, float f)
35 {
36         vector v1, v2, v3, v4;
37
38         hotspot = -1 * hotspot;
39
40         // hotspot-relative coordinates of the corners
41         v1 = hotspot;
42         v2 = hotspot + '1 0 0' * sz_x;
43         v3 = hotspot + '1 0 0' * sz_x + '0 1 0' * sz_y;
44         v4 = hotspot                  + '0 1 0' * sz_y;
45
46         // rotate them, and make them absolute
47         v1 = rotate(v1, rot) + org;
48         v2 = rotate(v2, rot) + org;
49         v3 = rotate(v3, rot) + org;
50         v4 = rotate(v4, rot) + org;
51
52         // draw them
53         R_BeginPolygon(pic, f);
54         R_PolygonVertex(v1, '0 0 0', rgb, a);
55         R_PolygonVertex(v2, '1 0 0', rgb, a);
56         R_PolygonVertex(v3, '1 1 0', rgb, a);
57         R_PolygonVertex(v4, '0 1 0', rgb, a);
58         R_EndPolygon();
59 }
60
61 void Draw_WaypointSprite()
62 {
63         string spriteimage;
64         float t;
65
66         if(self.lifetime)
67                 self.alpha = pow(bound(0, (self.fadetime - time) / self.lifetime, 1), waypointsprite_timealphaexponent);
68         else
69                 self.alpha = 1;
70
71         if(self.hideflags & 2)
72                 return; // radar only
73
74         if(self.hideflags & 1)
75                 if(cvar("cl_hidewaypoints"))
76                         return; // fixed waypoint
77
78         InterpolateOrigin_Do();
79
80         t = GetPlayerColor(player_localentnum - 1) + 1;
81
82         spriteimage = "";
83
84         // choose the sprite
85         switch(self.rule)
86         {
87                 case SPRITERULE_DEFAULT:
88                         spriteimage = self.netname;
89                         break;
90                 case SPRITERULE_TEAMPLAY:
91                         if(self.team == t)
92                                 spriteimage = self.netname2;
93                         else
94                                 spriteimage = self.netname;
95                         break;
96                 default:
97                         error("Invalid waypointsprite rule!");
98                         break;
99         }
100
101         if(spriteimage == "")
102                 return;
103         
104         float dist;
105         dist = vlen(self.origin - view_origin);
106         
107         float a;
108         a = self.alpha;
109
110         if(self.maxdistance > waypointsprite_normdistance)
111                 a *= pow(bound(0, (self.maxdistance - dist) / (self.maxdistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent);
112         else if(self.maxdistance > 0)
113                 a *= pow(bound(0, (waypointsprite_fadedistance - dist) / (waypointsprite_fadedistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent) * (1 - waypointsprite_minalpha) + waypointsprite_minalpha;
114
115         if(a <= 0)
116                 return;
117         
118         // draw the sprite image
119         vector o;
120         float rot;
121         o = project_3d_to_2d(self.origin);
122         rot = 0;
123
124         if(o_z < 0 || o_x < 0 || o_y < 0 || o_x > vid_conwidth || o_y > vid_conheight)
125         {
126                 // scale it to be just in view
127                 vector d;
128                 float f1, f2;
129                 d = o - '0.5 0 0' * vid_conwidth - '0 0.5 0' * vid_conheight;
130
131                 f1 = d_x / vid_conwidth;
132                 f2 = d_y / vid_conheight;
133
134                 if(max(f1, -f1) > max(f2, -f2))
135                 {
136                         if(f1 > 0)
137                         {
138                                 // RIGHT edge
139                                 d = d * (0.5 / f1);
140                                 rot = 1;
141                         }
142                         else
143                         {
144                                 // LEFT edge
145                                 d = d * (-0.5 / f1);
146                                 rot = 3;
147                         }
148                 }
149                 else
150                 {
151                         if(f2 > 0)
152                         {
153                                 // BOTTOM edge
154                                 d = d * (0.5 / f2);
155                                 rot = 0;
156                         }
157                         else
158                         {
159                                 // TOP edge
160                                 d = d * (-0.5 / f2);
161                                 rot = 2;
162                         }
163                 }
164
165                 o = d + '0.5 0 0' * vid_conwidth + '0 0.5 0' * vid_conheight;
166         }
167         o_z = 0;
168
169         drawrotpic(o, rot * 90 * DEG2RAD, strcat("models/sprites/", spriteimage), SPRITE_SIZE, SPRITE_HOTSPOT, '1 1 1', a, 0);
170 }
171
172 void Ent_WaypointSprite()
173 {
174         float sendflags, f;
175         sendflags = ReadByte();
176
177         self.draw2d = Draw_WaypointSprite;
178
179         InterpolateOrigin_Undo();
180
181         // unfortunately, this needs to be exact (for the 3D display)
182         self.origin_x = ReadCoord();
183         self.origin_y = ReadCoord();
184         self.origin_z = ReadCoord();
185
186         if(sendflags & 1)
187         {
188                 self.team = ReadByte();
189                 self.rule = ReadByte();
190         }
191
192         if(sendflags & 2)
193         {
194                 if(self.netname)
195                         strunzone(self.netname);
196                 self.netname = strzone(ReadString());
197         }
198
199         if(sendflags & 4)
200         {
201                 if(self.netname2)
202                         strunzone(self.netname2);
203                 self.netname2 = strzone(ReadString());
204         }
205
206         if(sendflags & 8)
207         {
208                 if(self.netname3)
209                         strunzone(self.netname3);
210                 self.netname3 = strzone(ReadString());
211         }
212
213         if(sendflags & 16)
214         {
215                 self.lifetime = ReadCoord();
216                 self.fadetime = ReadCoord();
217                 self.maxdistance = ReadShort();
218                 self.hideflags = ReadByte();
219         }
220
221         if(sendflags & 32)
222         {
223                 f = ReadByte();
224                 self.teamradar_icon = (f & 0x7F);
225                 if(f & 0x80)
226                         self.teamradar_time = time;
227                 self.teamradar_color_x = ReadByte() / 255.0;
228                 self.teamradar_color_y = ReadByte() / 255.0;
229                 self.teamradar_color_z = ReadByte() / 255.0;
230         }
231
232         InterpolateOrigin_Note();
233 }
234
235 void Ent_RemoveWaypointSprite()
236 {
237         if(self.netname)
238                 strunzone(self.netname);
239         if(self.netname2)
240                 strunzone(self.netname2);
241         if(self.netname3)
242                 strunzone(self.netname3);
243 }
244
245 void WaypointSprite_Init()
246 {
247         waypointsprite_fadedistance = vlen(world.maxs - world.mins);
248         waypointsprite_normdistance = cvar("g_waypointsprite_normdistance");
249         waypointsprite_minscale = cvar("g_waypointsprite_minscale");
250         waypointsprite_minalpha = cvar("g_waypointsprite_minalpha");
251         waypointsprite_distancealphaexponent = cvar("g_waypointsprite_distancealphaexponent");
252         waypointsprite_timealphaexponent = cvar("g_waypointsprite_timealphaexponent");
253 }