//------------------------------------------------------------------------------------
// Цикл звука
//------------------------------------------------------------------------------------
void Audio_LoopProc()
{
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// делаем установку слушателя (он в точке камеры)
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// получаем текущее положение камеры
VECTOR3D CurrentCameraLocation;
vw_GetCameraLocation(&CurrentCameraLocation);
VECTOR3D CurrentCameraRotation;
vw_GetCameraRotation(&CurrentCameraRotation);
VECTOR3D ListenerOriV1(0.0f, 0.0f, -1.0f);
RotatePoint(&ListenerOriV1, CurrentCameraRotation);
VECTOR3D ListenerOriV2(0.0f, 1.0f, 0.0f);
RotatePoint(&ListenerOriV2, CurrentCameraRotation);
// Position of the Listener.
ALfloat ListenerPos[3] = { CurrentCameraLocation.x, CurrentCameraLocation.y, CurrentCameraLocation.z };
// Velocity of the Listener.
ALfloat ListenerVel[3] = { 0.0f, 0.0f, 0.0f };
// Orientation of the Listener. (first 3 elements are "at", second 3 are "up")
// Also note that these should be units of '1'.
ALfloat ListenerOri[6] = { ListenerOriV1.x, ListenerOriV1.y, ListenerOriV1.z,
ListenerOriV2.x, ListenerOriV2.y, ListenerOriV2.z };
vw_Listener(ListenerPos, ListenerVel, ListenerOri);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// передаем управление, чтобы внутри ядра все сделали
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
vw_UpdateSound();
vw_UpdateMusic();
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// запускаем нужную музыку... только включили громкость или выключили
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if (!vw_GetMusicIsPlaying())
{
if (Setup.MusicSw) // если громкость не нулевая
if (Setup.Music_check) // если можно вообще играть
if (CurrentPlayingMusic != -1) // если установлен номер
if (vw_FindMusicByNum(MusicList[CurrentPlayingMusic]) == 0) // если это еще не играем
{
// создаем новый источник и проигрываем его
eMusic *Music;
Music = new eMusic;
vw_AttachMusic(Music);
MusicList[CurrentPlayingMusic] = Music->Num;
if (!Music->Play(GameMusicNames[CurrentPlayingMusic], 1.0f, Setup.MusicSw/10.0f, true, 0))
{
vw_ReleaseMusic(Music); Music = 0;
MusicList[CurrentPlayingMusic] = -1;
CurrentPlayingMusic = -1;
}
}
}
else
{
// если что-то играем, но звук уже выключен, нужно все убрать...
if (!Setup.MusicSw) // если громкость нулевая
if (Setup.Music_check) // но играть можно
{
vw_ReleaseAllMusic();
for (int i=0; i<MusicQuantity; i++)
MusicList[i] = -1;
}
}
}
//------------------------------------------------------------------------------------
// прорисовка фонта в 3д пространстве
//------------------------------------------------------------------------------------
void vw_DrawFont3D(float X, float Y, float Z, const char *Text, ...)
{
if (Text == 0) return;
// смотрим значения параметров в строке
char text[1024];
va_list ap;
va_start(ap, Text);
vsprintf(text, Text, ap);
va_end(ap);
// в text уже полная строка
if (strlen(text) == 0) return;
// прорисовка текста
const char *textdraw = text;
float Xstart = 0.0f;
// сразу определяем "базовую" ширину пробела
float SpaceWidth = vw_FindFontCharByUTF32(0x020)->AdvanceX;
// чтобы было более читаемо - делаем пробел не менее 2/3 ширины
if (SpaceWidth < (InternalFontSize * 0.65f)) SpaceWidth = InternalFontSize * 0.65f;
textdraw = text;
// для отрисовки
eTexture* CurrentTexture = 0;
int k=0;
// буфер для последовательности RI_QUADS
// войдет RI_2f_XY | RI_2f_TEX
#ifdef USE_GLES
float tmp[(2+2)*6*strlen(textdraw)];
#else
float tmp[(2+2)*4*strlen(textdraw)];
#endif
// установка свойств текстуры
vw_SetTextureBlend(true, RI_BLEND_SRCALPHA, RI_BLEND_INVSRCALPHA);
// всегда стаим белый цвет
vw_SetColor(1.0f, 1.0f, 1.0f, 1.0f);
vw_PushMatrix();
vw_Translate(VECTOR3D(X, Y, Z));
VECTOR3D CurrentCameraRotation;
vw_GetCameraRotation(&CurrentCameraRotation);
// поворачиваем к камере
vw_Rotate(CurrentCameraRotation.y, 0.0f, 1.0f, 0.0f);
vw_Rotate(CurrentCameraRotation.x, 1.0f, 0.0f, 0.0f);
// прорисовываем все символы
while (strlen(textdraw) > 0)
{
unsigned UTF32;
// преобразуем в утф32 и "сдвигаемся" на следующий символ в строке
textdraw = utf8_to_utf32(textdraw, &UTF32);
// находим наш текущий символ
eFontChar* DrawChar = vw_FindFontCharByUTF32(UTF32);
if (DrawChar == 0) DrawChar = vw_LoadFontChar(UTF32);
// первый символ - запоминаем его текстуру
if (CurrentTexture == 0) CurrentTexture = DrawChar->CharTexture;
// проверка на текстуру, если текстура поменялась - отрисовываем все что есть в буфере, если там что-то есть
if (CurrentTexture != DrawChar->CharTexture)
{
// если что-то было в буфере - выводим
if (k > 0)
{
// Установка текстуры
vw_SetTexture(0, CurrentTexture);
// отрисовываем все что есть в буфере
vw_SendVertices(RI_QUADS, 4*(k/16), RI_2f_XY | RI_1_TEX, tmp, 4*sizeof(float));
}
// запоминаем новую текстуру
CurrentTexture = DrawChar->CharTexture;
// сбрасываем счетчики
k=0;
}
// если не пробел - рисуем
if (UTF32 != 0x020)
{
float DrawX = Xstart + DrawChar->Left;
float DrawY = InternalFontSize - DrawChar->Top;
float ImageHeight = DrawChar->CharTexture->Height*1.0f;
float ImageWidth = DrawChar->CharTexture->Width*1.0f;
float FrameHeight = (DrawChar->TexturePositionBottom*1.0f )/ImageHeight;
float FrameWidth = (DrawChar->TexturePositionRight*1.0f )/ImageWidth;
float Yst = (DrawChar->TexturePositionTop*1.0f)/ImageHeight;
float Xst = (DrawChar->TexturePositionLeft*1.0f)/ImageWidth;
#ifdef USE_GLES
tmp[k++] = DrawX/10.0f;
tmp[k++] = (DrawY + DrawChar->Height)/10.0f;
tmp[k++] = Xst;
tmp[k++] = 1.0f-Yst;
tmp[k++] = DrawX/10.0f;
tmp[k++] = (DrawY + DrawChar->Height)/10.0f;
tmp[k++] = Xst;
tmp[k++] = 1.0f-Yst;
tmp[k++] = DrawX/10.0f;
tmp[k++] = DrawY/10.0f;
tmp[k++] = Xst;
tmp[k++] = 1.0f-FrameHeight;
tmp[k++] = (DrawX + DrawChar->Width)/10.0f;
tmp[k++] = (DrawY + DrawChar->Height)/10.0f;
tmp[k++] = FrameWidth;
tmp[k++] = 1.0f-Yst;
tmp[k++] = (DrawX + DrawChar->Width)/10.0f;
tmp[k++] = DrawY/10.0f;
tmp[k++] = FrameWidth;
tmp[k++] = 1.0f-FrameHeight;
tmp[k++] = (DrawX + DrawChar->Width)/10.0f;
tmp[k++] = DrawY/10.0f;
tmp[k++] = FrameWidth;
tmp[k++] = 1.0f-FrameHeight;
#else
tmp[k++] = DrawX/10.0f;
tmp[k++] = (DrawY + DrawChar->Height)/10.0f;
tmp[k++] = Xst;
tmp[k++] = 1.0f-Yst;
tmp[k++] = DrawX/10.0f;
tmp[k++] = DrawY/10.0f;
tmp[k++] = Xst;
tmp[k++] = 1.0f-FrameHeight;
tmp[k++] = (DrawX + DrawChar->Width)/10.0f;
tmp[k++] = DrawY/10.0f;
tmp[k++] = FrameWidth;
tmp[k++] = 1.0f-FrameHeight;
tmp[k++] = (DrawX + DrawChar->Width)/10.0f;
tmp[k++] = (DrawY + DrawChar->Height)/10.0f;
tmp[k++] = FrameWidth;
tmp[k++] = 1.0f-Yst;
#endif
Xstart += DrawChar->AdvanceX;
}
else
{
Xstart += SpaceWidth;
}
}
// если что-то было в буфере - выводим
if (k > 0)
{
// Установка текстуры
vw_SetTexture(0, CurrentTexture);
// отрисовываем все что есть в буфере
#ifdef USE_GLES
vw_SendVertices(RI_QUADS, 6*(k/16), RI_2f_XY | RI_1_TEX, tmp, 4*sizeof(float));
#else
vw_SendVertices(RI_QUADS, 4*(k/16), RI_2f_XY | RI_1_TEX, tmp, 4*sizeof(float));
#endif
}
vw_PopMatrix();
vw_SetTextureBlend(false, 0, 0);
vw_BindTexture(0, 0);
}
//-----------------------------------------------------------------------------
// прорисовка системы
//-----------------------------------------------------------------------------
void CSpaceStars::Draw()
{
// загрузка текстуры, уже должна быть подключена
if (Texture == 0) return;
VECTOR3D CurrentCameraRotation;
vw_GetCameraRotation(&CurrentCameraRotation);
// если еще нет последовательности, или камеру повернули - надо пересчитать прорисовку
if ((tmpDATA == 0 && VBO == 0) || CurrentCameraRotation.x != LastCameraAngleX || CurrentCameraRotation.y != LastCameraAngleY || CurrentCameraRotation.z != LastCameraAngleZ)
{
if (list != 0){delete [] list; list = 0;}
if (tmpDATA != 0){delete [] tmpDATA; tmpDATA = 0;}
if (VBO!=0){vw_DeleteVBO(*VBO); delete VBO; VBO=0;}
// находим реальное кол-во частиц на прорисовку
CStar *tmp = Start;
PrimitCount = 0;
// сохраняем данные
LastCameraAngleX = CurrentCameraRotation.x;
LastCameraAngleY = CurrentCameraRotation.y;
LastCameraAngleZ = CurrentCameraRotation.z;
// получаем текущее положение камеры
VECTOR3D CurrentCameraLocation;
vw_GetCameraLocation(&CurrentCameraLocation);
while (tmp!=0)
{
CStar *tmp2 = tmp->Next;
// небольшая оптимизация, если попадает в сферу - рисуем, нет - значит не видно
if (vw_SphereInFrustum(tmp->Location + CurrentCameraLocation, Size))
PrimitCount++;
tmp = tmp2;
}
// если рисовать нечего - выходим
if (PrimitCount == 0) return;
// список, в котором они будут упорядочены
list = new CStar*[PrimitCount]; if (list == 0) return;
int LenCount = 0;
float *Len = 0;
tmp = Start;
while (tmp!=0)
{
CStar *tmp2 = tmp->Next;
// небольшая оптимизация, если попадает в сферу - рисуем, нет - значит не видно
if (vw_SphereInFrustum(tmp->Location + CurrentCameraLocation, Size))
{
list[LenCount] = tmp;
LenCount++;
}
tmp = tmp2;
}
// если не поддерживаем/не включены шейдеры, или нет поддержки вбо
// делаем старым способом, через временный буфер
if (!Setup.UseGLSL)
{
// делаем массив для всех элементов
#ifdef USE_GLES
// войдет RI_3f_XYZ | RI_2f_TEX | RI_4ub_COLOR
tmpDATA = new float[6*(3+2+1)*PrimitCount]; if (tmpDATA == 0) return;
#else
// войдет RI_3f_XYZ | RI_2f_TEX | RI_4ub_COLOR
tmpDATA = new float[4*(3+2+1)*PrimitCount]; if (tmpDATA == 0) return;
#endif
GLubyte *tmpDATAub = (GLubyte *)tmpDATA;
// номер float'а в последовательности
int k=0;
for (int i=0; i<PrimitCount; i++)
{
// находим вектор камера-точка
VECTOR3D nnTmp;
// смотрим, если есть не нужно поворачивать, работаем с направлением
nnTmp = list[i]->Location^(-1.0f);
nnTmp.Normalize();
// находим перпендикуляр к вектору nnTmp
VECTOR3D nnTmp2;
nnTmp2.x = 1.0f;
nnTmp2.y = 1.0f;
nnTmp2.z = -(nnTmp.x + nnTmp.y)/nnTmp.z;
nnTmp2.Normalize();
// находим перпендикуляр к векторам nnTmp и nnTmp2
// файтически - a x b = ( aybz - byaz , azbx - bzax , axby - bxay );
VECTOR3D nnTmp3;
nnTmp3.x = nnTmp.y*nnTmp2.z - nnTmp2.y*nnTmp.z;
nnTmp3.y = nnTmp.z*nnTmp2.x - nnTmp2.z*nnTmp.x;
nnTmp3.z = nnTmp.x*nnTmp2.y - nnTmp2.x*nnTmp.y;
nnTmp3.Normalize();
// находим
VECTOR3D tmpAngle1,tmpAngle2,tmpAngle3,tmpAngle4;
tmpAngle1 = nnTmp3^(Size*1.5f);
tmpAngle3 = nnTmp3^(-Size*1.5f);
tmpAngle2 = nnTmp2^(Size*1.5f);
tmpAngle4 = nnTmp2^(-Size*1.5f);
GLubyte A = (GLubyte)(list[i]->Alpha*255);
// собираем четырехугольник
#ifdef USE_GLES
tmpDATA[k++] = list[i]->Location.x+tmpAngle3.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle3.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle3.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle3.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle3.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle3.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle2.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle2.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle2.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle4.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle4.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle4.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle1.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle1.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle1.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle1.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle1.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle1.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = 0.0f;
#else
tmpDATA[k++] = list[i]->Location.x+tmpAngle3.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle3.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle3.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle2.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle2.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle2.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle1.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle1.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle1.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle4.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle4.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle4.z; // Z
tmpDATAub[k*sizeof(float)] = 204;
tmpDATAub[k*sizeof(float)+1] = 204;
tmpDATAub[k*sizeof(float)+2] = 255;
tmpDATAub[k*sizeof(float)+3] = A;
k++;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = 1.0f;
#endif
}
}
else
{
// все нормально, работаем с шейдерами и вбо
// делаем массив для всех элементов
#ifdef USE_GLES
// войдет RI_3f_XYZ | RI_2f_TEX | RI_3f_NORMAL*/
tmpDATA = new float[6*(3+2+3)*PrimitCount]; if (tmpDATA == 0) return;
#else
// войдет RI_3f_XYZ | RI_2f_TEX | RI_3f_NORMAL*/
tmpDATA = new float[4*(3+2+3)*PrimitCount]; if (tmpDATA == 0) return;
#endif
// номер float'а в последовательности
int k=0;
for (int i=0; i<PrimitCount; i++)
{
// находим вектор камера-точка
VECTOR3D nnTmp;
// смотрим, если есть не нужно поворачивать, работаем с направлением
nnTmp = list[i]->Location^(-1.0f);
nnTmp.Normalize();
// находим перпендикуляр к вектору nnTmp
VECTOR3D nnTmp2;
nnTmp2.x = 1.0f;
nnTmp2.y = 1.0f;
nnTmp2.z = -(nnTmp.x + nnTmp.y)/nnTmp.z;
nnTmp2.Normalize();
// находим перпендикуляр к векторам nnTmp и nnTmp2
// файтически - a x b = ( aybz - byaz , azbx - bzax , axby - bxay );
VECTOR3D nnTmp3;
nnTmp3.x = nnTmp.y*nnTmp2.z - nnTmp2.y*nnTmp.z;
nnTmp3.y = nnTmp.z*nnTmp2.x - nnTmp2.z*nnTmp.x;
nnTmp3.z = nnTmp.x*nnTmp2.y - nnTmp2.x*nnTmp.y;
nnTmp3.Normalize();
// находим
VECTOR3D tmpAngle1,tmpAngle2,tmpAngle3,tmpAngle4;
tmpAngle1 = nnTmp3^(Size*1.5f);
tmpAngle3 = nnTmp3^(-Size*1.5f);
tmpAngle2 = nnTmp2^(Size*1.5f);
tmpAngle4 = nnTmp2^(-Size*1.5f);
// собираем четырехугольник
tmpDATA[k++] = list[i]->Location.x+tmpAngle3.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle3.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle3.z; // Z
tmpDATA[k++] = 0.0f;// не задействован
tmpDATA[k++] = 0.0f;// не задействован
tmpDATA[k++] = list[i]->AlphaDelta;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle2.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle2.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle2.z; // Z
tmpDATA[k++] = 0.0f;// не задействован
tmpDATA[k++] = 0.0f;// не задействован
tmpDATA[k++] = list[i]->AlphaDelta;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle1.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle1.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle1.z; // Z
tmpDATA[k++] = 0.0f;// не задействован
tmpDATA[k++] = 0.0f;// не задействован
tmpDATA[k++] = list[i]->AlphaDelta;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = 0.0f;
tmpDATA[k++] = list[i]->Location.x+tmpAngle4.x; // X
tmpDATA[k++] = list[i]->Location.y+tmpAngle4.y; // Y
tmpDATA[k++] = list[i]->Location.z+tmpAngle4.z; // Z
tmpDATA[k++] = 1.0f;// не задействован
tmpDATA[k++] = 1.0f;// не задействован
tmpDATA[k++] = list[i]->AlphaDelta;
tmpDATA[k++] = 1.0f;
tmpDATA[k++] = 1.0f;
}
if (CAPS->VBOSupported)
{
VBO = new unsigned int;
if (!vw_BuildVBO(4*PrimitCount, tmpDATA, 8, VBO))
{
delete VBO; VBO = 0;
}
else
{
// только если поддерживае вбо, иначе им рисуем
if (tmpDATA != 0){delete [] tmpDATA; tmpDATA = 0;}
}
}
if (list != 0){delete [] list; list = 0;}
}
if (Len != 0){delete [] Len; Len = 0;}
}
if (PrimitCount > 0)
{
vw_SetTexture(0, Texture);
vw_SetTextureBlend(true, RI_BLEND_SRCALPHA, RI_BLEND_ONE);
// получаем текущее положение камеры
VECTOR3D CurrentCameraLocation;
vw_GetCameraLocation(&CurrentCameraLocation);
CurrentCameraLocation += VECTOR3D(GameCameraGetDeviation()*0.9,-GameCameraGetDeviation()*0.5f,0.0f);
vw_PushMatrix();
vw_Translate(CurrentCameraLocation);
if (!Setup.UseGLSL)
{
#ifdef USE_GLES
vw_SendVertices(RI_QUADS, 6*PrimitCount, RI_3f_XYZ | RI_4ub_COLOR | RI_1_TEX, tmpDATA, 6*sizeof(float));
#else
vw_SendVertices(RI_QUADS, 4*PrimitCount, RI_3f_XYZ | RI_4ub_COLOR | RI_1_TEX, tmpDATA, 6*sizeof(float));
#endif
}
else
{
if (GLSL != 0)
{
vw_UseShaderProgram(GLSL);
vw_Uniform1i(GLSL, UniformLocations[0], 0);
vw_Uniform1f(GLSL, UniformLocations[1], Age);
}
vw_SendVertices(RI_QUADS, 4*PrimitCount, RI_3f_XYZ | RI_1_TEX | RI_3f_NORMAL, tmpDATA, 8*sizeof(float), VBO);
if (GLSL != 0) vw_StopShaderProgram();
}
vw_PopMatrix();
vw_SetTextureBlend(false, 0, 0);
}
vw_BindTexture(0, 0);
}
