← Back to branch summary

~ubuntu-branches/debian/sid/astromenace/sid

« back to all changes in this revision

Viewing changes to AstroMenaceSource/GraphicFX/SpaceStars/SpaceStars.cpp

  • Committer: Package Import Robot
  • Author(s): Boris Pek
  • Date: 2013-04-09 02:04:25 UTC
  • Revision ID: package-import@ubuntu.com-20130409020425-a7fl9xk4diamw6di
Tags: upstream-1.3.1+repack
Import upstream version 1.3.1+repack

Show diffs side-by-side

added added

removed removed

Lines of Context:
AstroMenaceSource/GraphicFX/SpaceStars/SpaceStars.cpp
 
1
/************************************************************************************
 
2
 
 
3
        AstroMenace (Hardcore 3D space shooter with spaceship upgrade possibilities)
 
4
        Copyright © 2006-2012 Michael Kurinnoy, Viewizard
 
5
 
 
6
 
 
7
        AstroMenace is free software: you can redistribute it and/or modify
 
8
        it under the terms of the GNU General Public License as published by
 
9
        the Free Software Foundation, either version 3 of the License, or
 
10
        (at your option) any later version.
 
11
 
 
12
        AstroMenace is distributed in the hope that it will be useful,
 
13
        but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
15
        GNU General Public License for more details.
 
16
 
 
17
        You should have received a copy of the GNU General Public License
 
18
        along with AstroMenace. If not, see <http://www.gnu.org/licenses/>.
 
19
 
 
20
 
 
21
        Web Site: http://www.viewizard.com/
 
22
        Project: http://sourceforge.net/projects/openastromenace/
 
23
        E-mail: viewizard@viewizard.com
 
24
 
 
25
*************************************************************************************/
 
26
 
 
27
 
 
28
#include "SpaceStars.h"
 
29
#include "../../Game.h"
 
30
 
 
31
 
 
32
 
 
33
 
 
34
//-----------------------------------------------------------------------------
 
35
// инициализация класса
 
36
//-----------------------------------------------------------------------------
 
37
CSpaceStars::CSpaceStars()
 
38
{
 
39
        Age = 0.0f;
 
40
        TimeLastUpdate = -1.0f;
 
41
 
 
42
        // положение системы
 
43
        Location = VECTOR3D( 0.0f, 0.0f, 0.0f);
 
44
 
 
45
        Size = 0.003f;
 
46
        CreationSize = VECTOR3D(5.21f,5.21f,5.21f);
 
47
        Texture = vw_FindTextureByName("DATA/GFX/flare1.tga");
 
48
        DeadZone = 5.2f;
 
49
 
 
50
 
 
51
 
 
52
        if (Setup.UseGLSL)
 
53
        {
 
54
                GLSL = vw_FindShaderByName("SpaceStars");
 
55
                UniformLocations[0] = vw_GetUniformLocation(GLSL, "ParticleTexture");
 
56
                UniformLocations[1] = vw_GetUniformLocation(GLSL, "ParticleAge");
 
57
        }
 
58
 
 
59
 
 
60
 
 
61
        // начальные установки для мартиц поворотов
 
62
        Matrix33Identity(CurrentRotationMat);
 
63
        Matrix33Identity(OldInvRotationMat);
 
64
 
 
65
        // настройка массива
 
66
        Start = 0;
 
67
        End = 0;
 
68
 
 
69
 
 
70
        unsigned int ParticlesCreated = 10000 - 4000*Setup.VisualEffectsQuality;
 
71
 
 
72
        // пока не создадим все необходимые частицы
 
73
        while (ParticlesCreated > 0)
 
74
        {
 
75
                // создаем новую частицу
 
76
                CStar *NewParticle = 0;
 
77
                NewParticle = new CStar; if (NewParticle == 0) return;
 
78
 
 
79
 
 
80
                // считаем значение альфы
 
81
                NewParticle->Alpha = 0.5f + 0.5f * vw_Randf1;
 
82
                // убираем переполнение
 
83
                Clamp( NewParticle->Alpha, 0.0f, 1.0f );
 
84
                // считаем дельту альфы
 
85
                NewParticle->AlphaDelta = (1.5f + 1.5f * vw_Randf1) / 3.0f;
 
86
 
 
87
 
 
88
 
 
89
                // выпускаем частицу возле места нахождения системы
 
90
                // в сфере
 
91
                VECTOR3D tmp;
 
92
                float minDist = CreationSize.x*CreationSize.x+CreationSize.y*CreationSize.y+CreationSize.z*CreationSize.z;
 
93
                // если зона больше чем радиус излучения - выключаем ее
 
94
                if (minDist <= DeadZone*DeadZone) DeadZone = 0.0f;
 
95
 
 
96
                // прибавляем к рандому, чтобы избежать вероятности появления всех трех нулей и деления на ноль в дальнейшем
 
97
                tmp.x = (vw_Randf0 + 0.00001f) * CreationSize.x;
 
98
                tmp.y = vw_Randf0 * CreationSize.y;
 
99
                tmp.z = vw_Randf0 * CreationSize.z;
 
100
                float ParticleDist = tmp.x*tmp.x + tmp.y*tmp.y + tmp.z*tmp.z;
 
101
                while (ParticleDist > minDist || ParticleDist < DeadZone*DeadZone)
 
102
                {
 
103
                        if (ParticleDist > minDist)
 
104
                        {
 
105
                                // ум. радиус
 
106
                                VECTOR3D tmp1 = tmp;
 
107
                                tmp1.Normalize();
 
108
                                tmp1 = tmp1^(1/100.0f);
 
109
                                tmp = tmp - tmp1;
 
110
                        }
 
111
                        if ( ParticleDist < DeadZone*DeadZone)
 
112
                        {
 
113
                                // ув. радиус
 
114
                                VECTOR3D tmp1 = tmp;
 
115
                                tmp1.Normalize();
 
116
                                tmp1 = tmp1^(1/100.0f);
 
117
                                tmp = tmp + tmp1;
 
118
 
 
119
                                if (tmp.x > 0.0f)
 
120
                                {if (tmp.x > CreationSize.x) tmp.x = CreationSize.x;}
 
121
                                else
 
122
                                {if (tmp.x < -CreationSize.x) tmp.x = -CreationSize.x;}
 
123
                                if (tmp.y > 0.0f)
 
124
                                {if (tmp.y > CreationSize.y) tmp.y = CreationSize.y;}
 
125
                                else
 
126
                                {if (tmp.y < -CreationSize.y) tmp.y = -CreationSize.y;}
 
127
 
 
128
                                if (tmp.z > 0.0f)
 
129
                                {if (tmp.z > CreationSize.z) tmp.z = CreationSize.z;}
 
130
                                else
 
131
                                {if (tmp.z < -CreationSize.z) tmp.z = -CreationSize.z;}
 
132
                        }
 
133
                        ParticleDist = tmp.x*tmp.x + tmp.y*tmp.y + tmp.z*tmp.z;
 
134
                }
 
135
 
 
136
                Matrix33CalcPoint(&tmp, CurrentRotationMat);
 
137
                NewParticle->Location = Location + tmp;
 
138
 
 
139
 
 
140
 
 
141
                // подключаем частицу к системе
 
142
                Attach(NewParticle);
 
143
 
 
144
                // уменьшаем необходимое количество частиц
 
145
                ParticlesCreated--;
 
146
        }
 
147
 
 
148
 
 
149
 
 
150
 
 
151
        list = 0;
 
152
        tmpDATA = 0;
 
153
        VBO = 0;
 
154
        LastCameraAngleX = LastCameraAngleY = LastCameraAngleZ = 0.0f;
 
155
}
 
156
 
 
157
 
 
158
//-----------------------------------------------------------------------------
 
159
//      При разрушении класса
 
160
//-----------------------------------------------------------------------------
 
161
CSpaceStars::~CSpaceStars()
 
162
{
 
163
        // полностью освобождаем память от всех частиц в системе
 
164
        CStar *tmp = Start;
 
165
        while (tmp!=0)
 
166
        {
 
167
                CStar *tmp2 = tmp->Next;
 
168
                Detach(tmp);
 
169
                delete tmp; tmp = 0;
 
170
                tmp = tmp2;
 
171
        }
 
172
 
 
173
        if (VBO!=0){vw_DeleteVBO(*VBO); delete VBO; VBO=0;}
 
174
        if (tmpDATA!=0){delete [] tmpDATA; tmpDATA = 0;}
 
175
        if (list!=0){delete [] list; list = 0;}
 
176
}
 
177
 
 
178
 
 
179
//-----------------------------------------------------------------------------
 
180
//      подключить частицу к системе
 
181
//-----------------------------------------------------------------------------
 
182
void CSpaceStars::Attach(CStar * NewParticle)
 
183
{
 
184
        if (NewParticle == 0) return;
 
185
 
 
186
        // первый в списке...
 
187
        if (End == 0)
 
188
        {
 
189
                NewParticle->Prev = 0;
 
190
                NewParticle->Next = 0;
 
191
                Start = NewParticle;
 
192
                End = NewParticle;
 
193
        }
 
194
        else // продолжаем заполнение...
 
195
        {
 
196
                NewParticle->Prev = End;
 
197
                NewParticle->Next = 0;
 
198
                End->Next = NewParticle;
 
199
                End = NewParticle;
 
200
        }
 
201
 
 
202
}
 
203
 
 
204
 
 
205
//-----------------------------------------------------------------------------
 
206
//      отключить ее от системы
 
207
//-----------------------------------------------------------------------------
 
208
void CSpaceStars::Detach(CStar * OldParticle)
 
209
{
 
210
        if (OldParticle == 0) return;
 
211
 
 
212
        // переустанавливаем указатели...
 
213
        if (Start == OldParticle) Start = OldParticle->Next;
 
214
        if (End == OldParticle) End = OldParticle->Prev;
 
215
 
 
216
 
 
217
        if (OldParticle->Next != 0) OldParticle->Next->Prev = OldParticle->Prev;
 
218
                else if (OldParticle->Prev != 0) OldParticle->Prev->Next = 0;
 
219
        if (OldParticle->Prev != 0) OldParticle->Prev->Next = OldParticle->Next;
 
220
                else if (OldParticle->Next != 0) OldParticle->Next->Prev = 0;
 
221
 
 
222
}
 
223
 
 
224
 
 
225
 
 
226
 
 
227
 
 
228
//-----------------------------------------------------------------------------
 
229
// обновление системы
 
230
//-----------------------------------------------------------------------------
 
231
bool CSpaceStars::Update(float Time)
 
232
{
 
233
        // первый раз... просто берем время
 
234
        if (TimeLastUpdate == -1.0f) {TimeLastUpdate = Time;return true;}
 
235
 
 
236
        // Time - это абсолютное время, вычисляем дельту
 
237
        float TimeDelta = Time - TimeLastUpdate;
 
238
        // быстро вызвали еще раз... время не изменилось, или почти не изменилось
 
239
        if (TimeDelta == 0.0f) return true;
 
240
 
 
241
        TimeLastUpdate = Time;
 
242
        Age += TimeDelta;
 
243
 
 
244
 
 
245
        // эти расчеты делаем в шейдере, они нам не нужны
 
246
        if (!Setup.UseGLSL)
 
247
        {
 
248
                // для всех частиц
 
249
                CStar *tmp = Start;
 
250
                while (tmp!=0)
 
251
                {
 
252
                        CStar *tmp2 = tmp->Next;
 
253
                        // функция вернет false, если частица уже мертва
 
254
                        if (!tmp->Update(TimeDelta))
 
255
                        {
 
256
                                Detach(tmp);
 
257
                                delete tmp; tmp = 0;
 
258
                        }
 
259
                        tmp = tmp2;
 
260
                }
 
261
 
 
262
                // обновляем данные в массиве прорисовки
 
263
                if (tmpDATA != 0 && list != 0)
 
264
                {
 
265
                        // для каждого меняем альфу
 
266
                        int k=0;
 
267
                        GLubyte A;
 
268
                        GLubyte *tmpDATAub = (GLubyte *)tmpDATA;
 
269
 
 
270
                        for (int i=0; i<PrimitCount; i++)
 
271
                        {
 
272
                                A = (GLubyte)(list[i]->Alpha*255);
 
273
 
 
274
                                k+=3;
 
275
                                tmpDATAub[k*sizeof(float)+3] = A;
 
276
                                k+=6;
 
277
                                tmpDATAub[k*sizeof(float)+3] = A;
 
278
                                k+=6;
 
279
                                tmpDATAub[k*sizeof(float)+3] = A;
 
280
                                k+=6;
 
281
                                tmpDATAub[k*sizeof(float)+3] = A;
 
282
                                k+=3;
 
283
                        }
 
284
                }
 
285
        }
 
286
 
 
287
    return true;
 
288
}
 
289
 
 
290
 
 
291
 
 
292
 
 
293
 
 
294
//-----------------------------------------------------------------------------
 
295
// прорисовка системы
 
296
//-----------------------------------------------------------------------------
 
297
void CSpaceStars::Draw()
 
298
{
 
299
 
 
300
        // загрузка текстуры, уже должна быть подключена
 
301
        if (Texture == 0) return;
 
302
 
 
303
        VECTOR3D CurrentCameraRotation;
 
304
        vw_GetCameraRotation(&CurrentCameraRotation);
 
305
 
 
306
 
 
307
        // если еще нет последовательности, или камеру повернули - надо пересчитать прорисовку
 
308
        if ((tmpDATA == 0 && VBO == 0) || CurrentCameraRotation.x != LastCameraAngleX || CurrentCameraRotation.y != LastCameraAngleY || CurrentCameraRotation.z != LastCameraAngleZ)
 
309
        {
 
310
 
 
311
                if (list != 0){delete [] list; list = 0;}
 
312
                if (tmpDATA != 0){delete [] tmpDATA; tmpDATA = 0;}
 
313
                if (VBO!=0){vw_DeleteVBO(*VBO); delete VBO; VBO=0;}
 
314
 
 
315
                // находим реальное кол-во частиц на прорисовку
 
316
                CStar *tmp = Start;
 
317
                PrimitCount = 0;
 
318
 
 
319
                // сохраняем данные
 
320
                LastCameraAngleX = CurrentCameraRotation.x;
 
321
                LastCameraAngleY = CurrentCameraRotation.y;
 
322
                LastCameraAngleZ = CurrentCameraRotation.z;
 
323
 
 
324
                // получаем текущее положение камеры
 
325
                VECTOR3D CurrentCameraLocation;
 
326
                vw_GetCameraLocation(&CurrentCameraLocation);
 
327
 
 
328
 
 
329
                while (tmp!=0)
 
330
                {
 
331
                        CStar *tmp2 = tmp->Next;
 
332
                        // небольшая оптимизация, если попадает в сферу - рисуем, нет - значит не видно
 
333
                        if (vw_SphereInFrustum(tmp->Location + CurrentCameraLocation, Size))
 
334
                                PrimitCount++;
 
335
                        tmp = tmp2;
 
336
                }
 
337
 
 
338
                // если рисовать нечего - выходим
 
339
                if (PrimitCount == 0) return;
 
340
 
 
341
                // список, в котором они будут упорядочены
 
342
                list = new CStar*[PrimitCount]; if (list == 0) return;
 
343
                int LenCount = 0;
 
344
                float *Len = 0;
 
345
 
 
346
                tmp = Start;
 
347
                while (tmp!=0)
 
348
                {
 
349
                        CStar *tmp2 = tmp->Next;
 
350
                        // небольшая оптимизация, если попадает в сферу - рисуем, нет - значит не видно
 
351
                        if (vw_SphereInFrustum(tmp->Location + CurrentCameraLocation, Size))
 
352
                        {
 
353
                                list[LenCount] = tmp;
 
354
                                LenCount++;
 
355
                        }
 
356
                        tmp = tmp2;
 
357
                }
 
358
 
 
359
 
 
360
 
 
361
                // если не поддерживаем/не включены шейдеры, или нет поддержки вбо
 
362
                // делаем старым способом, через временный буфер
 
363
                if (!Setup.UseGLSL)
 
364
                {
 
365
                        // делаем массив для всех элементов
 
366
                        // войдет RI_3f_XYZ | RI_2f_TEX | RI_4ub_COLOR
 
367
                        tmpDATA = new float[4*(3+2+1)*PrimitCount]; if (tmpDATA == 0) return;
 
368
                        GLubyte *tmpDATAub = (GLubyte *)tmpDATA;
 
369
 
 
370
                        // номер float'а в последовательности
 
371
                        int k=0;
 
372
 
 
373
                        for (int i=0; i<PrimitCount; i++)
 
374
                        {
 
375
                                // находим вектор камера-точка
 
376
                                VECTOR3D nnTmp;
 
377
                                // смотрим, если есть не нужно поворачивать, работаем с направлением
 
378
                                nnTmp = list[i]->Location^(-1.0f);
 
379
                                nnTmp.Normalize();
 
380
                                // находим перпендикуляр к вектору nnTmp
 
381
                                VECTOR3D nnTmp2;
 
382
                                nnTmp2.x = 1.0f;
 
383
                                nnTmp2.y = 1.0f;
 
384
                                nnTmp2.z = -(nnTmp.x + nnTmp.y)/nnTmp.z;
 
385
                                nnTmp2.Normalize();
 
386
                                // находим перпендикуляр к векторам nnTmp и nnTmp2
 
387
                                // файтически - a x b = ( aybz - byaz , azbx - bzax , axby - bxay );
 
388
                                VECTOR3D nnTmp3;
 
389
                                nnTmp3.x = nnTmp.y*nnTmp2.z - nnTmp2.y*nnTmp.z;
 
390
                                nnTmp3.y = nnTmp.z*nnTmp2.x - nnTmp2.z*nnTmp.x;
 
391
                                nnTmp3.z = nnTmp.x*nnTmp2.y - nnTmp2.x*nnTmp.y;
 
392
                                nnTmp3.Normalize();
 
393
 
 
394
                                // находим
 
395
                                VECTOR3D tmpAngle1,tmpAngle2,tmpAngle3,tmpAngle4;
 
396
 
 
397
                                tmpAngle1 = nnTmp3^(Size*1.5f);
 
398
                                tmpAngle3 = nnTmp3^(-Size*1.5f);
 
399
                                tmpAngle2 = nnTmp2^(Size*1.5f);
 
400
                                tmpAngle4 = nnTmp2^(-Size*1.5f);
 
401
 
 
402
 
 
403
                                GLubyte A = (GLubyte)(list[i]->Alpha*255);
 
404
 
 
405
                                // собираем четырехугольник
 
406
 
 
407
                                tmpDATA[k++] = list[i]->Location.x+tmpAngle3.x; // X
 
408
                                tmpDATA[k++] = list[i]->Location.y+tmpAngle3.y;         // Y
 
409
                                tmpDATA[k++] = list[i]->Location.z+tmpAngle3.z;         // Z
 
410
                                tmpDATAub[k*sizeof(float)] = 204;
 
411
                                tmpDATAub[k*sizeof(float)+1] = 204;
 
412
                                tmpDATAub[k*sizeof(float)+2] = 255;
 
413
                                tmpDATAub[k*sizeof(float)+3] = A;
 
414
                                k++;
 
415
                                tmpDATA[k++] = 0.0f;
 
416
                                tmpDATA[k++] = 1.0f;
 
417
 
 
418
                                tmpDATA[k++] = list[i]->Location.x+tmpAngle2.x; // X
 
419
                                tmpDATA[k++] = list[i]->Location.y+tmpAngle2.y;         // Y
 
420
                                tmpDATA[k++] = list[i]->Location.z+tmpAngle2.z;         // Z
 
421
                                tmpDATAub[k*sizeof(float)] = 204;
 
422
                                tmpDATAub[k*sizeof(float)+1] = 204;
 
423
                                tmpDATAub[k*sizeof(float)+2] = 255;
 
424
                                tmpDATAub[k*sizeof(float)+3] = A;
 
425
                                k++;
 
426
                                tmpDATA[k++] = 0.0f;
 
427
                                tmpDATA[k++] = 0.0f;
 
428
 
 
429
                                tmpDATA[k++] = list[i]->Location.x+tmpAngle1.x; // X
 
430
                                tmpDATA[k++] = list[i]->Location.y+tmpAngle1.y;         // Y
 
431
                                tmpDATA[k++] = list[i]->Location.z+tmpAngle1.z;         // Z
 
432
                                tmpDATAub[k*sizeof(float)] = 204;
 
433
                                tmpDATAub[k*sizeof(float)+1] = 204;
 
434
                                tmpDATAub[k*sizeof(float)+2] = 255;
 
435
                                tmpDATAub[k*sizeof(float)+3] = A;
 
436
                                k++;
 
437
                                tmpDATA[k++] = 1.0f;
 
438
                                tmpDATA[k++] = 0.0f;
 
439
 
 
440
                                tmpDATA[k++] = list[i]->Location.x+tmpAngle4.x; // X
 
441
                                tmpDATA[k++] = list[i]->Location.y+tmpAngle4.y;         // Y
 
442
                                tmpDATA[k++] = list[i]->Location.z+tmpAngle4.z;         // Z
 
443
                                tmpDATAub[k*sizeof(float)] = 204;
 
444
                                tmpDATAub[k*sizeof(float)+1] = 204;
 
445
                                tmpDATAub[k*sizeof(float)+2] = 255;
 
446
                                tmpDATAub[k*sizeof(float)+3] = A;
 
447
                                k++;
 
448
                                tmpDATA[k++] = 1.0f;
 
449
                                tmpDATA[k++] = 1.0f;
 
450
                        }
 
451
                }
 
452
                else
 
453
                {
 
454
                        // все нормально, работаем с шейдерами и вбо
 
455
 
 
456
 
 
457
                        // делаем массив для всех элементов
 
458
                        // войдет RI_3f_XYZ | RI_2f_TEX | RI_3f_NORMAL*/
 
459
                        tmpDATA = new float[4*(3+2+3)*PrimitCount]; if (tmpDATA == 0) return;
 
460
 
 
461
                        // номер float'а в последовательности
 
462
                        int k=0;
 
463
 
 
464
                        for (int i=0; i<PrimitCount; i++)
 
465
                        {
 
466
                                // находим вектор камера-точка
 
467
                                VECTOR3D nnTmp;
 
468
                                // смотрим, если есть не нужно поворачивать, работаем с направлением
 
469
                                nnTmp = list[i]->Location^(-1.0f);
 
470
                                nnTmp.Normalize();
 
471
                                // находим перпендикуляр к вектору nnTmp
 
472
                                VECTOR3D nnTmp2;
 
473
                                nnTmp2.x = 1.0f;
 
474
                                nnTmp2.y = 1.0f;
 
475
                                nnTmp2.z = -(nnTmp.x + nnTmp.y)/nnTmp.z;
 
476
                                nnTmp2.Normalize();
 
477
                                // находим перпендикуляр к векторам nnTmp и nnTmp2
 
478
                                // файтически - a x b = ( aybz - byaz , azbx - bzax , axby - bxay );
 
479
                                VECTOR3D nnTmp3;
 
480
                                nnTmp3.x = nnTmp.y*nnTmp2.z - nnTmp2.y*nnTmp.z;
 
481
                                nnTmp3.y = nnTmp.z*nnTmp2.x - nnTmp2.z*nnTmp.x;
 
482
                                nnTmp3.z = nnTmp.x*nnTmp2.y - nnTmp2.x*nnTmp.y;
 
483
                                nnTmp3.Normalize();
 
484
 
 
485
                                // находим
 
486
                                VECTOR3D tmpAngle1,tmpAngle2,tmpAngle3,tmpAngle4;
 
487
 
 
488
                                tmpAngle1 = nnTmp3^(Size*1.5f);
 
489
                                tmpAngle3 = nnTmp3^(-Size*1.5f);
 
490
                                tmpAngle2 = nnTmp2^(Size*1.5f);
 
491
                                tmpAngle4 = nnTmp2^(-Size*1.5f);
 
492
 
 
493
 
 
494
                                // собираем четырехугольник
 
495
 
 
496
                                tmpDATA[k++] = list[i]->Location.x+tmpAngle3.x; // X
 
497
                                tmpDATA[k++] = list[i]->Location.y+tmpAngle3.y;         // Y
 
498
                                tmpDATA[k++] = list[i]->Location.z+tmpAngle3.z;         // Z
 
499
                                tmpDATA[k++] = 0.0f;// не задействован
 
500
                                tmpDATA[k++] = 0.0f;// не задействован
 
501
                                tmpDATA[k++] = list[i]->AlphaDelta;
 
502
                                tmpDATA[k++] = 0.0f;
 
503
                                tmpDATA[k++] = 1.0f;
 
504
 
 
505
                                tmpDATA[k++] = list[i]->Location.x+tmpAngle2.x; // X
 
506
                                tmpDATA[k++] = list[i]->Location.y+tmpAngle2.y;         // Y
 
507
                                tmpDATA[k++] = list[i]->Location.z+tmpAngle2.z;         // Z
 
508
                                tmpDATA[k++] = 0.0f;// не задействован
 
509
                                tmpDATA[k++] = 0.0f;// не задействован
 
510
                                tmpDATA[k++] = list[i]->AlphaDelta;
 
511
                                tmpDATA[k++] = 0.0f;
 
512
                                tmpDATA[k++] = 0.0f;
 
513
 
 
514
                                tmpDATA[k++] = list[i]->Location.x+tmpAngle1.x; // X
 
515
                                tmpDATA[k++] = list[i]->Location.y+tmpAngle1.y;         // Y
 
516
                                tmpDATA[k++] = list[i]->Location.z+tmpAngle1.z;         // Z
 
517
                                tmpDATA[k++] = 0.0f;// не задействован
 
518
                                tmpDATA[k++] = 0.0f;// не задействован
 
519
                                tmpDATA[k++] = list[i]->AlphaDelta;
 
520
                                tmpDATA[k++] = 1.0f;
 
521
                                tmpDATA[k++] = 0.0f;
 
522
 
 
523
                                tmpDATA[k++] = list[i]->Location.x+tmpAngle4.x; // X
 
524
                                tmpDATA[k++] = list[i]->Location.y+tmpAngle4.y;         // Y
 
525
                                tmpDATA[k++] = list[i]->Location.z+tmpAngle4.z;         // Z
 
526
                                tmpDATA[k++] = 1.0f;// не задействован
 
527
                                tmpDATA[k++] = 1.0f;// не задействован
 
528
                                tmpDATA[k++] = list[i]->AlphaDelta;
 
529
                                tmpDATA[k++] = 1.0f;
 
530
                                tmpDATA[k++] = 1.0f;
 
531
                        }
 
532
 
 
533
                        if (CAPS->VBOSupported)
 
534
                        {
 
535
                                VBO = new unsigned int;
 
536
                                if (!vw_BuildVBO(4*PrimitCount, tmpDATA, 8, VBO))
 
537
                                {
 
538
                                        delete VBO; VBO = 0;
 
539
                                }
 
540
                                else
 
541
                                {
 
542
                                        // только если поддерживае вбо, иначе им рисуем
 
543
                                        if (tmpDATA != 0){delete [] tmpDATA; tmpDATA = 0;}
 
544
                                }
 
545
                        }
 
546
 
 
547
                        if (list != 0){delete [] list; list = 0;}
 
548
                }
 
549
 
 
550
                if (Len != 0){delete [] Len; Len = 0;}
 
551
        }
 
552
 
 
553
 
 
554
 
 
555
 
 
556
 
 
557
        if (PrimitCount > 0)
 
558
        {
 
559
                vw_SetTexture(0, Texture);
 
560
                vw_SetTextureBlend(true, RI_BLEND_SRCALPHA, RI_BLEND_ONE);
 
561
 
 
562
 
 
563
                // получаем текущее положение камеры
 
564
                VECTOR3D CurrentCameraLocation;
 
565
                vw_GetCameraLocation(&CurrentCameraLocation);
 
566
                CurrentCameraLocation += VECTOR3D(GameCameraGetDeviation()*0.9,-GameCameraGetDeviation()*0.5f,0.0f);
 
567
 
 
568
 
 
569
                vw_PushMatrix();
 
570
                vw_Translate(CurrentCameraLocation);
 
571
 
 
572
 
 
573
 
 
574
                if (!Setup.UseGLSL)
 
575
                {
 
576
                        vw_SendVertices(RI_QUADS, 4*PrimitCount, RI_3f_XYZ | RI_4ub_COLOR | RI_1_TEX, tmpDATA, 6*sizeof(float));
 
577
                }
 
578
                else
 
579
                {
 
580
                        if (GLSL != 0)
 
581
                        {
 
582
                                vw_UseShaderProgram(GLSL);
 
583
                                vw_Uniform1i(GLSL, UniformLocations[0], 0);
 
584
                                vw_Uniform1f(GLSL, UniformLocations[1], Age);
 
585
                        }
 
586
 
 
587
                        vw_SendVertices(RI_QUADS, 4*PrimitCount, RI_3f_XYZ | RI_1_TEX | RI_3f_NORMAL, tmpDATA, 8*sizeof(float), VBO);
 
588
 
 
589
                        if (GLSL != 0) vw_StopShaderProgram();
 
590
                }
 
591
 
 
592
 
 
593
                vw_PopMatrix();
 
594
 
 
595
                vw_SetTextureBlend(false, 0, 0);
 
596
        }
 
597
 
 
598
 
 
599
 
 
600
 
 
601
 
 
602
        vw_BindTexture(0, 0);
 
603
}
 
604