1775 lines
50 KiB
C++
1775 lines
50 KiB
C++
/*
|
|
gl_grass.cpp - auto grass system
|
|
Copyright (C) 2014 Uncle Mike
|
|
|
|
This program 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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.
|
|
*/
|
|
|
|
#include "hud.h"
|
|
#include "cl_util.h"
|
|
#include "gl_local.h"
|
|
#include "gl_world.h"
|
|
#include "gl_grass.h"
|
|
#include "gl_shader.h"
|
|
#include <utlarray.h>
|
|
#include <stringlib.h>
|
|
#include "vertex_fmt.h"
|
|
|
|
#define LEAF_MAX_EXPAND 48.0f
|
|
#define DENSITY_FACTOR 0.0001f
|
|
|
|
grasstexture_t grasstexs[GRASS_TEXTURES];
|
|
CUtlArray<grassentry_t> grassInfo;
|
|
|
|
// intermediate arrays used for creating VBO's
|
|
static gvert_t m_arraygvert[MAX_GRASS_VERTS];
|
|
static word m_indexarray[MAX_GRASS_ELEMS];
|
|
static int m_iNumVertex, m_iNumIndex, m_iVertexState;
|
|
static int m_iTotalVerts = 0;
|
|
static int m_iTextureWidth;
|
|
static int m_iTextureHeight;
|
|
static float m_flGrassFadeStart;
|
|
static float m_flGrassFadeDist;
|
|
static float m_flGrassFadeEnd;
|
|
|
|
static void CreateBufferBaseGL21( grass_t *pOut, gvert_t *arrayxvert )
|
|
{
|
|
static gvert_v0_gl21_t arraygvert[MAX_GRASS_VERTS];
|
|
|
|
// convert to GLSL-compacted array
|
|
for( int i = 0; i < pOut->numVerts; i++ )
|
|
{
|
|
arraygvert[i].center[0] = arrayxvert[i].center[0];
|
|
arraygvert[i].center[1] = arrayxvert[i].center[1];
|
|
arraygvert[i].center[2] = arrayxvert[i].center[2];
|
|
arraygvert[i].center[3] = arrayxvert[i].center[3];
|
|
arraygvert[i].light[0] = arrayxvert[i].light[0];
|
|
arraygvert[i].light[1] = arrayxvert[i].light[1];
|
|
arraygvert[i].light[2] = arrayxvert[i].light[2];
|
|
arraygvert[i].light[3] = arrayxvert[i].light[3];
|
|
arraygvert[i].normal[0] = arrayxvert[i].normal[0];
|
|
arraygvert[i].normal[1] = arrayxvert[i].normal[1];
|
|
arraygvert[i].normal[2] = arrayxvert[i].normal[2];
|
|
arraygvert[i].normal[3] = arrayxvert[i].normal[3];
|
|
}
|
|
|
|
pOut->cacheSize = pOut->numVerts * sizeof( gvert_v0_gl21_t );
|
|
|
|
// create grass static buffer
|
|
pglGenBuffersARB( 1, &pOut->vbo );
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, pOut->vbo );
|
|
pglBufferDataARB( GL_ARRAY_BUFFER_ARB, pOut->cacheSize, &arraygvert[0], GL_STATIC_DRAW_ARB );
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
|
|
}
|
|
|
|
static void BindBufferBaseGL21( grass_t *pOut, int attrFlags )
|
|
{
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, pOut->vbo );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v0_gl21_t ), (void *)offsetof( gvert_v0_gl21_t, center ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_POSITION );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_NORMAL, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v0_gl21_t ), (void *)offsetof( gvert_v0_gl21_t, normal ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_NORMAL );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v0_gl21_t ), (void *)offsetof( gvert_v0_gl21_t, light ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_COLOR );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_STYLES, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof( gvert_v0_gl21_t ), (void *)offsetof( gvert_v0_gl21_t, styles ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_STYLES );
|
|
}
|
|
|
|
static void CreateBufferBaseGL30( grass_t *pOut, gvert_t *arrayxvert )
|
|
{
|
|
static gvert_v0_gl30_t arraygvert[MAX_GRASS_VERTS];
|
|
|
|
// convert to GLSL-compacted array
|
|
for( int i = 0; i < pOut->numVerts; i++ )
|
|
{
|
|
arraygvert[i].center[0] = FloatToHalf( arrayxvert[i].center[0] );
|
|
arraygvert[i].center[1] = FloatToHalf( arrayxvert[i].center[1] );
|
|
arraygvert[i].center[2] = FloatToHalf( arrayxvert[i].center[2] );
|
|
arraygvert[i].center[3] = FloatToHalf( arrayxvert[i].center[3] );
|
|
arraygvert[i].light[0] = arrayxvert[i].light[0];
|
|
arraygvert[i].light[1] = arrayxvert[i].light[1];
|
|
arraygvert[i].light[2] = arrayxvert[i].light[2];
|
|
arraygvert[i].light[3] = arrayxvert[i].light[3];
|
|
CompressNormalizedVector( arraygvert[i].normal, arrayxvert[i].normal );
|
|
arraygvert[i].normal[3] = arrayxvert[i].normal[3];
|
|
}
|
|
|
|
pOut->cacheSize = pOut->numVerts * sizeof( gvert_v0_gl30_t );
|
|
|
|
// create grass static buffer
|
|
pglGenBuffersARB( 1, &pOut->vbo );
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, pOut->vbo );
|
|
pglBufferDataARB( GL_ARRAY_BUFFER_ARB, pOut->cacheSize, &arraygvert[0], GL_STATIC_DRAW_ARB );
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
|
|
}
|
|
|
|
static void BindBufferBaseGL30( grass_t *pOut, int attrFlags )
|
|
{
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, pOut->vbo );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_POSITION, 4, GL_HALF_FLOAT_ARB, GL_FALSE, sizeof( gvert_v0_gl30_t ), (void *)offsetof( gvert_v0_gl30_t, center ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_POSITION );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_NORMAL, 4, GL_BYTE, GL_FALSE, sizeof( gvert_v0_gl30_t ), (void *)offsetof( gvert_v0_gl30_t, normal ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_NORMAL );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v0_gl30_t ), (void *)offsetof( gvert_v0_gl30_t, light ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_COLOR );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_STYLES, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof( gvert_v0_gl30_t ), (void *)offsetof( gvert_v0_gl30_t, styles ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_STYLES );
|
|
}
|
|
|
|
static void CreateBufferBaseBumpGL21( grass_t *pOut, gvert_t *arrayxvert )
|
|
{
|
|
static gvert_v1_gl21_t arraygvert[MAX_GRASS_VERTS];
|
|
|
|
// convert to GLSL-compacted array
|
|
for( int i = 0; i < pOut->numVerts; i++ )
|
|
{
|
|
arraygvert[i].center[0] = arrayxvert[i].center[0];
|
|
arraygvert[i].center[1] = arrayxvert[i].center[1];
|
|
arraygvert[i].center[2] = arrayxvert[i].center[2];
|
|
arraygvert[i].center[3] = arrayxvert[i].center[3];
|
|
arraygvert[i].light[0] = arrayxvert[i].light[0];
|
|
arraygvert[i].light[1] = arrayxvert[i].light[1];
|
|
arraygvert[i].light[2] = arrayxvert[i].light[2];
|
|
arraygvert[i].light[3] = arrayxvert[i].light[3];
|
|
arraygvert[i].delux[0] = arrayxvert[i].delux[0];
|
|
arraygvert[i].delux[1] = arrayxvert[i].delux[1];
|
|
arraygvert[i].delux[2] = arrayxvert[i].delux[2];
|
|
arraygvert[i].delux[3] = arrayxvert[i].delux[3];
|
|
arraygvert[i].normal[0] = arrayxvert[i].normal[0];
|
|
arraygvert[i].normal[1] = arrayxvert[i].normal[1];
|
|
arraygvert[i].normal[2] = arrayxvert[i].normal[2];
|
|
arraygvert[i].normal[3] = arrayxvert[i].normal[3];
|
|
}
|
|
|
|
pOut->cacheSize = pOut->numVerts * sizeof( gvert_v1_gl21_t );
|
|
|
|
// create grass static buffer
|
|
pglGenBuffersARB( 1, &pOut->vbo );
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, pOut->vbo );
|
|
pglBufferDataARB( GL_ARRAY_BUFFER_ARB, pOut->cacheSize, &arraygvert[0], GL_STATIC_DRAW_ARB );
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
|
|
}
|
|
|
|
static void BindBufferBaseBumpGL21( grass_t *pOut, int attrFlags )
|
|
{
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, pOut->vbo );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v1_gl21_t ), (void *)offsetof( gvert_v1_gl21_t, center ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_POSITION );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_NORMAL, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v1_gl21_t ), (void *)offsetof( gvert_v1_gl21_t, normal ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_NORMAL );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v1_gl21_t ), (void *)offsetof( gvert_v1_gl21_t, light ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_COLOR );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_VECS, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v1_gl21_t ), (void *)offsetof( gvert_v1_gl21_t, delux ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_VECS );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_STYLES, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof( gvert_v1_gl21_t ), (void *)offsetof( gvert_v1_gl21_t, styles ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_STYLES );
|
|
}
|
|
|
|
static void CreateBufferBaseBumpGL30( grass_t *pOut, gvert_t *arrayxvert )
|
|
{
|
|
static gvert_v1_gl30_t arraygvert[MAX_GRASS_VERTS];
|
|
|
|
// convert to GLSL-compacted array
|
|
for( int i = 0; i < pOut->numVerts; i++ )
|
|
{
|
|
arraygvert[i].center[0] = FloatToHalf( arrayxvert[i].center[0] );
|
|
arraygvert[i].center[1] = FloatToHalf( arrayxvert[i].center[1] );
|
|
arraygvert[i].center[2] = FloatToHalf( arrayxvert[i].center[2] );
|
|
arraygvert[i].center[3] = FloatToHalf( arrayxvert[i].center[3] );
|
|
arraygvert[i].light[0] = arrayxvert[i].light[0];
|
|
arraygvert[i].light[1] = arrayxvert[i].light[1];
|
|
arraygvert[i].light[2] = arrayxvert[i].light[2];
|
|
arraygvert[i].light[3] = arrayxvert[i].light[3];
|
|
arraygvert[i].delux[0] = arrayxvert[i].delux[0];
|
|
arraygvert[i].delux[1] = arrayxvert[i].delux[1];
|
|
arraygvert[i].delux[2] = arrayxvert[i].delux[2];
|
|
arraygvert[i].delux[3] = arrayxvert[i].delux[3];
|
|
CompressNormalizedVector( arraygvert[i].normal, arrayxvert[i].normal );
|
|
arraygvert[i].normal[3] = arrayxvert[i].normal[3];
|
|
}
|
|
|
|
pOut->cacheSize = pOut->numVerts * sizeof( gvert_v1_gl30_t );
|
|
|
|
// create grass static buffer
|
|
pglGenBuffersARB( 1, &pOut->vbo );
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, pOut->vbo );
|
|
pglBufferDataARB( GL_ARRAY_BUFFER_ARB, pOut->numVerts * sizeof( gvert_v1_gl30_t ), &arraygvert[0], GL_STATIC_DRAW_ARB );
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
|
|
}
|
|
|
|
static void BindBufferBaseBumpGL30( grass_t *pOut, int attrFlags )
|
|
{
|
|
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, pOut->vbo );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_POSITION, 4, GL_HALF_FLOAT_ARB, GL_FALSE, sizeof( gvert_v1_gl30_t ), (void *)offsetof( gvert_v1_gl30_t, center ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_POSITION );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_NORMAL, 4, GL_BYTE, GL_FALSE, sizeof( gvert_v1_gl30_t ), (void *)offsetof( gvert_v1_gl30_t, normal ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_NORMAL );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v1_gl30_t ), (void *)offsetof( gvert_v1_gl30_t, light ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_COLOR );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_VECS, 4, GL_FLOAT, GL_FALSE, sizeof( gvert_v1_gl30_t ), (void *)offsetof( gvert_v1_gl30_t, delux ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_VECS );
|
|
|
|
pglVertexAttribPointerARB( ATTR_INDEX_LIGHT_STYLES, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof( gvert_v1_gl30_t ), (void *)offsetof( gvert_v1_gl30_t, styles ));
|
|
pglEnableVertexAttribArrayARB( ATTR_INDEX_LIGHT_STYLES );
|
|
}
|
|
|
|
static void CreateIndexBuffer( grass_t *pOut, unsigned short *arrayelems )
|
|
{
|
|
uint cacheSize = pOut->numElems * sizeof( word );
|
|
|
|
pglGenBuffersARB( 1, &pOut->ibo );
|
|
pglBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, pOut->ibo );
|
|
pglBufferDataARB( GL_ELEMENT_ARRAY_BUFFER_ARB, cacheSize, &arrayelems[0], GL_STATIC_DRAW_ARB );
|
|
pglBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
|
|
|
|
// update total buffer size
|
|
pOut->cacheSize += cacheSize;
|
|
}
|
|
|
|
static void BindIndexBuffer( grass_t *pOut )
|
|
{
|
|
pglBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, pOut->ibo );
|
|
}
|
|
|
|
unsigned int SelectGrassLoader( void )
|
|
{
|
|
if( FBitSet( world->features, WORLD_HAS_DELUXEMAP ) && r_grass->value > 1.0f )
|
|
return GRASSLOADER_BASEBUMP;
|
|
return GRASSLOADER_BASE;
|
|
}
|
|
|
|
static grass_loader_t pfnMeshLoaderGL21[GRASSLOADER_COUNT] =
|
|
{
|
|
{ CreateBufferBaseGL21, BindBufferBaseGL21, "BaseBuffer" },
|
|
{ CreateBufferBaseBumpGL21, BindBufferBaseBumpGL21, "BumpBaseBuffer" },
|
|
};
|
|
|
|
static grass_loader_t pfnMeshLoaderGL30[GRASSLOADER_COUNT] =
|
|
{
|
|
{ CreateBufferBaseGL30, BindBufferBaseGL30, "BaseBuffer" },
|
|
{ CreateBufferBaseBumpGL30, BindBufferBaseBumpGL30, "BumpBaseBuffer" },
|
|
};
|
|
|
|
/*
|
|
================
|
|
R_GetPointForBush
|
|
|
|
compute 16 points for single bush
|
|
================
|
|
*/
|
|
static const Vector R_GetPointForBush( int vertexNum, const Vector &pos, float scale )
|
|
{
|
|
float s1 = ( m_iTextureWidth * 0.075f ) * scale;
|
|
float s2 = ( m_iTextureWidth * 0.1f ) * scale;
|
|
float s3 = ( m_iTextureHeight * 0.1f ) * scale;
|
|
|
|
switch(( vertexNum & 15 ))
|
|
{
|
|
case 0: return Vector( pos.x - s2, pos.y, pos.z );
|
|
case 1: return Vector( pos.x - s2, pos.y, pos.z + s3 );
|
|
case 2: return Vector( pos.x + s2, pos.y, pos.z + s3 );
|
|
case 3: return Vector( pos.x + s2, pos.y, pos.z );
|
|
case 4: return Vector( pos.x, pos.y - s2, pos.z );
|
|
case 5: return Vector( pos.x, pos.y - s2, pos.z + s3 );
|
|
case 6: return Vector( pos.x, pos.y + s2, pos.z + s3 );
|
|
case 7: return Vector( pos.x, pos.y + s2, pos.z );
|
|
case 8: return Vector( pos.x - s1, pos.y - s1, pos.z );
|
|
case 9: return Vector( pos.x - s1, pos.y - s1, pos.z + s3 );
|
|
case 10: return Vector( pos.x + s1, pos.y + s1, pos.z + s3 );
|
|
case 11: return Vector( pos.x + s1, pos.y + s1, pos.z );
|
|
case 12: return Vector( pos.x - s1, pos.y + s1, pos.z );
|
|
case 13: return Vector( pos.x - s1, pos.y + s1, pos.z + s3 );
|
|
case 14: return Vector( pos.x + s1, pos.y - s1, pos.z + s3 );
|
|
case 15: return Vector( pos.x + s1, pos.y - s1, pos.z );
|
|
}
|
|
|
|
return g_vecZero; // error
|
|
}
|
|
/*
|
|
================
|
|
R_GetTexCoordForBush
|
|
|
|
get fixed texcoord for bush
|
|
================
|
|
*/
|
|
static const Vector2D R_GetTexCoordForBush( int vertexNum )
|
|
{
|
|
switch(( vertexNum & 7 ))
|
|
{
|
|
case 0: return Vector2D( 0.0f, 1.0f );
|
|
case 1: return Vector2D( 0.0f, 0.0f );
|
|
case 2: return Vector2D( 1.0f, 0.0f );
|
|
case 3: return Vector2D( 1.0f, 1.0f );
|
|
case 4: return Vector2D( 1.0f, 1.0f );
|
|
case 5: return Vector2D( 1.0f, 0.0f );
|
|
case 6: return Vector2D( 0.0f, 0.0f );
|
|
case 7: return Vector2D( 0.0f, 1.0f );
|
|
}
|
|
|
|
return Vector2D( 0.0f, 0.0f ); // error
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GetNormalForBush
|
|
|
|
get fixed normals for single bush
|
|
================
|
|
*/
|
|
static const Vector R_GetNormalForBush( int vertexNum )
|
|
{
|
|
switch(( vertexNum & 15 ))
|
|
{
|
|
case 0: return Vector( 0.0f, 1.0f, 0.0f );
|
|
case 1: return Vector( 0.0f, 1.0f, 0.0f );
|
|
case 2: return Vector( 0.0f, 1.0f, 0.0f );
|
|
case 3: return Vector( 0.0f, 1.0f, 0.0f );
|
|
case 4: return Vector( -1.0f, 0.0f, 0.0f );
|
|
case 5: return Vector( -1.0f, 0.0f, 0.0f );
|
|
case 6: return Vector( -1.0f, 0.0f, 0.0f );
|
|
case 7: return Vector( -1.0f, 0.0f, 0.0f );
|
|
case 8: return Vector( -0.707107f, 0.707107f, 0.0f );
|
|
case 9: return Vector( -0.707107f, 0.707107f, 0.0f );
|
|
case 10: return Vector( -0.707107f, 0.707107f, 0.0f );
|
|
case 11: return Vector( -0.707107f, 0.707107f, 0.0f );
|
|
case 12: return Vector( 0.707107f, 0.707107f, 0.0f );
|
|
case 13: return Vector( 0.707107f, 0.707107f, 0.0f );
|
|
case 14: return Vector( 0.707107f, 0.707107f, 0.0f );
|
|
case 15: return Vector( 0.707107f, 0.707107f, 0.0f );
|
|
}
|
|
|
|
return g_vecZero; // error
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_AdvanceVertex
|
|
|
|
routine to build quad sequences
|
|
================
|
|
*/
|
|
bool R_GrassAdvanceVertex( void )
|
|
{
|
|
if((( m_iNumIndex + 6 ) >= MAX_GRASS_ELEMS ) || (( m_iNumVertex + 4 ) >= MAX_GRASS_VERTS ))
|
|
return false;
|
|
|
|
if( m_iVertexState++ < 3 )
|
|
{
|
|
m_indexarray[m_iNumIndex++] = m_iNumVertex;
|
|
}
|
|
else
|
|
{
|
|
// we've already done triangle (0, 1, 2), now draw (2, 3, 0)
|
|
m_indexarray[m_iNumIndex++] = m_iNumVertex - 1;
|
|
m_indexarray[m_iNumIndex++] = m_iNumVertex;
|
|
m_indexarray[m_iNumIndex++] = m_iNumVertex - 3;
|
|
m_iVertexState = 0;
|
|
}
|
|
m_iNumVertex++;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassLightForVertex
|
|
|
|
We already have a valid spot on texture
|
|
Just find lightmap point and update grass color
|
|
================
|
|
*/
|
|
void R_GrassLightForVertex( msurface_t *fa, mextrasurf_t *es, const Vector &vertex, float posz, float light[MAXLIGHTMAPS], float delux[MAXLIGHTMAPS] )
|
|
{
|
|
if( !worldmodel->lightdata || !fa->samples )
|
|
return;
|
|
|
|
float sample_size = Mod_SampleSizeForFace( fa );
|
|
Vector pos = Vector( vertex.x, vertex.y, posz ); // drop to floor
|
|
float s = DotProduct( pos, fa->info->lmvecs[0] ) + fa->info->lmvecs[0][3] - fa->info->lightmapmins[0];
|
|
float t = DotProduct( pos, fa->info->lmvecs[1] ) + fa->info->lmvecs[1][3] - fa->info->lightmapmins[1];
|
|
int smax = (fa->info->lightextents[0] / sample_size) + 1;
|
|
int tmax = (fa->info->lightextents[1] / sample_size) + 1;
|
|
int size = smax * tmax;
|
|
int map;
|
|
|
|
// some bushes may be out of current poly
|
|
s = bound( 0, s, fa->info->lightextents[0] );
|
|
t = bound( 0, t, fa->info->lightextents[1] );
|
|
s /= sample_size;
|
|
t /= sample_size;
|
|
|
|
color24 *lm = fa->samples + Q_rint( t ) * smax + Q_rint( s );
|
|
|
|
for( map = 0; map < MAXLIGHTMAPS && fa->styles[map] != 255; map++ )
|
|
{
|
|
color24 out;
|
|
out.r = TEXTURE_TO_TEXGAMMA( lm->r );
|
|
out.g = TEXTURE_TO_TEXGAMMA( lm->g );
|
|
out.b = TEXTURE_TO_TEXGAMMA( lm->b );
|
|
light[map] = PackColor( out );
|
|
lm += size; // skip to next lightmap
|
|
}
|
|
|
|
if( !es->normals ) return;
|
|
|
|
color24 *dm = es->normals + Q_rint( t ) * smax + Q_rint( s );
|
|
Vector vec_x, vec_y, vec_z;
|
|
matrix3x3 mat;
|
|
|
|
// flat TBN for better results
|
|
vec_x = Vector( fa->info->lmvecs[0] );
|
|
vec_y = Vector( fa->info->lmvecs[1] );
|
|
if( FBitSet( fa->flags, SURF_PLANEBACK ))
|
|
vec_z = -fa->plane->normal;
|
|
else vec_z = fa->plane->normal;
|
|
|
|
// create tangent space rotational matrix
|
|
mat.SetForward( vec_x.Normalize( ));
|
|
mat.SetRight( -vec_y.Normalize( ));
|
|
mat.SetUp( vec_z.Normalize( ));
|
|
|
|
for( map = 0; map < MAXLIGHTMAPS && fa->styles[map] != 255; map++ )
|
|
{
|
|
float f = (1.0f / 128.0f);
|
|
Vector normal = Vector(((float)dm->r - 128.0f) * f, ((float)dm->g - 128.0f) * f, ((float)dm->b - 128.0f) * f);
|
|
delux[map] = NormalToFloat( mat.VectorRotate( normal ));
|
|
dm += size; // skip to next lightmap
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_CreateSingleBush
|
|
|
|
create a bush with specified pos
|
|
================
|
|
*/
|
|
bool R_CreateSingleBush( msurface_t *surf, mextrasurf_t *es, grasshdr_t *hdr, const Vector &pos, float size )
|
|
{
|
|
for( int i = 0; i < 16; i++ )
|
|
{
|
|
gvert_t *entry = &m_arraygvert[m_iNumVertex];
|
|
Vector vertex = R_GetPointForBush( i, pos, size );
|
|
memcpy( entry->styles, surf->styles, sizeof( entry->styles ));
|
|
R_GrassLightForVertex( surf, es, vertex, pos.z, entry->light, entry->delux );
|
|
AddPointToBounds( vertex, hdr->mins, hdr->maxs ); // build bbox for grass
|
|
Vector dir = ( vertex - pos ).Normalize();
|
|
float scale = ( vertex - pos ).Length();
|
|
|
|
entry->center[0] = pos.x;
|
|
entry->center[1] = pos.y;
|
|
entry->center[2] = pos.z;
|
|
entry->center[3] = scale;
|
|
entry->normal[0] = dir.x;
|
|
entry->normal[1] = dir.y;
|
|
entry->normal[2] = dir.z;
|
|
entry->normal[3] = i;
|
|
|
|
// generate indices
|
|
if( !R_GrassAdvanceVertex( ))
|
|
{
|
|
// vertexes is out
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void R_CreateSurfaceVBO( grass_t *pOut )
|
|
{
|
|
if( !m_iNumVertex ) return; // empty mesh?
|
|
|
|
GL_CheckVertexArrayBinding();
|
|
|
|
// determine optimal mesh loader
|
|
uint attribs = 0; // unused
|
|
uint type = SelectGrassLoader();
|
|
|
|
// move data to video memory
|
|
if( glConfig.version < ACTUAL_GL_VERSION )
|
|
pfnMeshLoaderGL21[type].CreateBuffer( pOut, m_arraygvert );
|
|
else pfnMeshLoaderGL30[type].CreateBuffer( pOut, m_arraygvert );
|
|
CreateIndexBuffer( pOut, m_indexarray );
|
|
|
|
// link it with vertex array object
|
|
pglGenVertexArrays( 1, &pOut->vao );
|
|
pglBindVertexArray( pOut->vao );
|
|
if( glConfig.version < ACTUAL_GL_VERSION )
|
|
pfnMeshLoaderGL21[type].BindBuffer( pOut, attribs );
|
|
else pfnMeshLoaderGL30[type].BindBuffer( pOut, attribs );
|
|
BindIndexBuffer( pOut );
|
|
pglBindVertexArray( GL_FALSE );
|
|
|
|
// update stats
|
|
tr.total_vbo_memory += pOut->cacheSize;
|
|
}
|
|
|
|
void R_DeleteSurfaceVBO( grass_t *pOut )
|
|
{
|
|
if( pOut->vao ) pglDeleteVertexArrays( 1, &pOut->vao );
|
|
if( pOut->vbo ) pglDeleteBuffersARB( 1, &pOut->vbo );
|
|
if( pOut->ibo ) pglDeleteBuffersARB( 1, &pOut->ibo );
|
|
tr.total_vbo_memory -= pOut->cacheSize;
|
|
pOut->cacheSize = 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_BuildGrassMesh
|
|
|
|
build mesh with single texture
|
|
================
|
|
*/
|
|
bool R_BuildGrassMesh( msurface_t *surf, mextrasurf_t *es, grassentry_t *entry, grasshdr_t *hdr, grass_t *out )
|
|
{
|
|
mfaceinfo_t *land = surf->texinfo->faceinfo;
|
|
bvert_t *v0, *v1, *v2;
|
|
|
|
// update random set to get predictable positions for grass 'random' placement
|
|
RANDOM_SEED(( surf - worldmodel->surfaces ) * entry->seed );
|
|
|
|
m_iNumVertex = m_iNumIndex = m_iVertexState = 0;
|
|
|
|
m_iTextureWidth = RENDER_GET_PARM( PARM_TEX_WIDTH, grasstexs[entry->texture].gl_texturenum );
|
|
m_iTextureHeight = RENDER_GET_PARM( PARM_TEX_HEIGHT, grasstexs[entry->texture].gl_texturenum );
|
|
|
|
// turn the face into a bunch of polygons, and compute the area of each
|
|
v0 = &world->vertexes[es->firstvertex];
|
|
|
|
for( int i = 1; i < es->numverts - 1; i++ )
|
|
{
|
|
v1 = &world->vertexes[es->firstvertex+i+0];
|
|
v2 = &world->vertexes[es->firstvertex+i+1];
|
|
|
|
// compute two triangle edges
|
|
Vector e1 = v1->vertex - v0->vertex;
|
|
Vector e2 = v2->vertex - v0->vertex;
|
|
|
|
// compute the triangle area
|
|
Vector areaVec = CrossProduct( e1, e2 );
|
|
float normalLength = areaVec.Length();
|
|
float area = 0.5f * normalLength;
|
|
|
|
// compute the number of samples to take
|
|
int numSamples = area * entry->density * DENSITY_FACTOR;
|
|
|
|
// now take a sample, and randomly place an object there
|
|
for( int j = 0; j < numSamples; j++ )
|
|
{
|
|
// Create a random sample...
|
|
float u = RANDOM_FLOAT( 0.0f, 1.0f );
|
|
float v = RANDOM_FLOAT( 0.0f, 1.0f );
|
|
|
|
if( v > ( 1.0f - u ))
|
|
{
|
|
u = 1.0f - u;
|
|
v = 1.0f - v;
|
|
}
|
|
|
|
float size = RANDOM_FLOAT( entry->min, entry->max );
|
|
|
|
Vector pos = v0->vertex + e1 * u + e2 * v;
|
|
|
|
if( !Mod_CheckLayerNameForPixel( land, pos, entry->name ))
|
|
continue; // rejected by heightmap
|
|
|
|
if( !R_CreateSingleBush( surf, es, hdr, pos, size ))
|
|
goto build_mesh; // vertices is out (more than 2048 bushes per surface created)
|
|
}
|
|
}
|
|
|
|
// nothing to added?
|
|
if( !m_iNumVertex ) return false;
|
|
|
|
build_mesh:
|
|
// give lightnums from surface
|
|
memcpy( out->lights, es->lights, sizeof( byte ) * MAXDYNLIGHTS );
|
|
out->texture = entry->texture;
|
|
out->numVerts = m_iNumVertex;
|
|
out->numElems = m_iNumIndex;
|
|
R_CreateSurfaceVBO( out );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_ConstructGrassForSurface
|
|
|
|
compile all the grassdata with
|
|
specified texture into single VBO
|
|
================
|
|
*/
|
|
void R_ConstructGrassForSurface( msurface_t *surf, mextrasurf_t *es )
|
|
{
|
|
// already init or not specified?
|
|
if( es->grass || !es->grasscount )
|
|
return;
|
|
|
|
size_t grasshdr_size = sizeof( grasshdr_t ) + sizeof( grass_t ) * ( es->grasscount - 1 );
|
|
grasshdr_t *hdr = es->grass = (grasshdr_t *)IEngineStudio.Mem_Calloc( 1, grasshdr_size );
|
|
hdr->mins = es->mins;
|
|
hdr->maxs = es->maxs;
|
|
hdr->count = 0;
|
|
|
|
for( int i = 0; i < grassInfo.Count(); i++ )
|
|
{
|
|
grassentry_t *entry = &grassInfo[i];
|
|
|
|
if( !Mod_CheckLayerNameForSurf( surf, entry->name ))
|
|
continue;
|
|
|
|
// create a single mesh for all the bushes that have same texture
|
|
if( !R_BuildGrassMesh( surf, es, entry, hdr, &hdr->g[hdr->count] ))
|
|
continue; // failed to build for some reasons
|
|
|
|
hdr->count++;
|
|
}
|
|
|
|
ClearBits( surf->flags, SURF_GRASS_UPDATE );
|
|
|
|
// bah! failed to create
|
|
if( !hdr->count )
|
|
{
|
|
Mem_Free( es->grass );
|
|
es->grasscount = 0;
|
|
es->grass = NULL;
|
|
}
|
|
|
|
// restore normal randomization
|
|
RANDOM_SEED( 0 );
|
|
}
|
|
|
|
void R_RemoveGrassForSurface( mextrasurf_t *es )
|
|
{
|
|
ClearBits( es->surf->flags, SURF_GRASS_UPDATE );
|
|
|
|
// not specified?
|
|
if( !es->grass ) return;
|
|
|
|
grasshdr_t *hdr = es->grass;
|
|
|
|
for( int i = 0; i < hdr->count; i++ )
|
|
R_DeleteSurfaceVBO( &hdr->g[i] );
|
|
|
|
es->grass = NULL;
|
|
Mem_Free( hdr );
|
|
}
|
|
|
|
void R_DrawGrassMeshFromBuffer( const grass_t *mesh )
|
|
{
|
|
pglBindVertexArray( mesh->vao );
|
|
|
|
if( GL_Support( R_DRAW_RANGEELEMENTS_EXT ))
|
|
pglDrawRangeElementsEXT( GL_TRIANGLES, 0, mesh->numVerts - 1, mesh->numElems, GL_UNSIGNED_SHORT, 0 );
|
|
else pglDrawElements( GL_TRIANGLES, mesh->numElems, GL_UNSIGNED_SHORT, 0 );
|
|
|
|
r_stats.c_total_tris += (mesh->numVerts / 2);
|
|
r_stats.num_flushes++;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_SetSurfaceUniforms
|
|
|
|
================
|
|
*/
|
|
void R_SetGrassUniforms( word hProgram, grass_t *grass )
|
|
{
|
|
Vector lightdir;
|
|
float *v;
|
|
|
|
if( RI->currentshader != &glsl_programs[hProgram] )
|
|
GL_BindShader( &glsl_programs[hProgram] );
|
|
|
|
glsl_program_t *shader = RI->currentshader;
|
|
gl_state_t *glm = GL_GetCache( grass->hCachedMatrix );
|
|
CDynLight *pl = RI->currentlight; // may be NULL
|
|
|
|
// sometime we can't set the uniforms
|
|
if( !shader || !shader->numUniforms || !shader->uniforms )
|
|
return;
|
|
|
|
// setup specified uniforms (and texture bindings)
|
|
for( int i = 0; i < shader->numUniforms; i++ )
|
|
{
|
|
uniform_t *u = &shader->uniforms[i];
|
|
|
|
switch( u->type )
|
|
{
|
|
case UT_COLORMAP:
|
|
u->SetValue( grasstexs[grass->texture].gl_texturenum );
|
|
break;
|
|
case UT_PROJECTMAP:
|
|
if( pl && pl->type == LIGHT_SPOT )
|
|
u->SetValue( pl->spotlightTexture );
|
|
else u->SetValue( tr.whiteTexture );
|
|
break;
|
|
case UT_SHADOWMAP:
|
|
case UT_SHADOWMAP0:
|
|
if( pl ) u->SetValue( pl->shadowTexture[0] );
|
|
else u->SetValue( tr.depthTexture );
|
|
break;
|
|
case UT_SHADOWMAP1:
|
|
if( pl ) u->SetValue( pl->shadowTexture[1] );
|
|
else u->SetValue( tr.depthTexture );
|
|
break;
|
|
case UT_SHADOWMAP2:
|
|
if( pl ) u->SetValue( pl->shadowTexture[2] );
|
|
else u->SetValue( tr.depthTexture );
|
|
break;
|
|
case UT_SHADOWMAP3:
|
|
if( pl ) u->SetValue( pl->shadowTexture[3] );
|
|
else u->SetValue( tr.depthTexture );
|
|
break;
|
|
case UT_LIGHTMAP:
|
|
case UT_DELUXEMAP:
|
|
case UT_DECALMAP:
|
|
// unacceptable for grass
|
|
u->SetValue( tr.whiteTexture );
|
|
break;
|
|
case UT_SCREENMAP:
|
|
u->SetValue( tr.screen_color );
|
|
break;
|
|
case UT_DEPTHMAP:
|
|
u->SetValue( tr.screen_depth );
|
|
break;
|
|
case UT_FITNORMALMAP:
|
|
u->SetValue( tr.normalsFitting );
|
|
break;
|
|
case UT_MODELMATRIX:
|
|
u->SetValue( &glm->modelMatrix[0] );
|
|
break;
|
|
case UT_SCREENSIZEINV:
|
|
u->SetValue( 1.0f / (float)glState.width, 1.0f / (float)glState.height );
|
|
break;
|
|
case UT_ZFAR:
|
|
u->SetValue( -tr.farclip * 1.74f );
|
|
break;
|
|
case UT_LIGHTSTYLEVALUES:
|
|
u->SetValue( &tr.lightstyle[0], MAX_LIGHTSTYLES );
|
|
break;
|
|
case UT_REALTIME:
|
|
u->SetValue( (float)tr.time );
|
|
break;
|
|
case UT_FOGPARAMS:
|
|
u->SetValue( tr.fogColor[0], tr.fogColor[1], tr.fogColor[2], tr.fogDensity );
|
|
break;
|
|
case UT_SHADOWPARMS:
|
|
if( pl != NULL )
|
|
{
|
|
float shadowWidth = 1.0f / (float)RENDER_GET_PARM( PARM_TEX_WIDTH, pl->shadowTexture[0] );
|
|
float shadowHeight = 1.0f / (float)RENDER_GET_PARM( PARM_TEX_HEIGHT, pl->shadowTexture[0] );
|
|
// depth scale and bias and shadowmap resolution
|
|
u->SetValue( shadowWidth, shadowHeight, -pl->projectionMatrix[2][2], pl->projectionMatrix[3][2] );
|
|
}
|
|
else u->SetValue( 0.0f, 0.0f, 0.0f, 0.0f );
|
|
break;
|
|
case UT_VIEWORIGIN:
|
|
u->SetValue( tr.cached_vieworigin.x, tr.cached_vieworigin.y, tr.cached_vieworigin.z );
|
|
break;
|
|
case UT_SHADOWMATRIX:
|
|
if( pl ) u->SetValue( &pl->gl_shadowMatrix[0][0], MAX_SHADOWMAPS );
|
|
break;
|
|
case UT_SHADOWSPLITDIST:
|
|
v = RI->view.parallelSplitDistances;
|
|
u->SetValue( v[0], v[1], v[2], v[3] );
|
|
break;
|
|
case UT_TEXELSIZE:
|
|
u->SetValue( 1.0f / (float)sunSize[0], 1.0f / (float)sunSize[1], 1.0f / (float)sunSize[2], 1.0f / (float)sunSize[3] );
|
|
break;
|
|
case UT_GAMMATABLE:
|
|
u->SetValue( &tr.gamma_table[0][0], 64 );
|
|
break;
|
|
case UT_LIGHTDIR:
|
|
if( pl )
|
|
{
|
|
if( pl->type == LIGHT_DIRECTIONAL ) lightdir = -tr.sky_normal;
|
|
else lightdir = pl->frustum.GetPlane( FRUSTUM_FAR )->normal;
|
|
u->SetValue( lightdir.x, lightdir.y, lightdir.z, pl->fov );
|
|
}
|
|
break;
|
|
case UT_LIGHTDIFFUSE:
|
|
if( pl ) u->SetValue( pl->color.x, pl->color.y, pl->color.z );
|
|
break;
|
|
case UT_LIGHTORIGIN:
|
|
if( pl ) u->SetValue( pl->origin.x, pl->origin.y, pl->origin.z, ( 1.0f / pl->radius ));
|
|
break;
|
|
case UT_LIGHTVIEWPROJMATRIX:
|
|
if( pl )
|
|
{
|
|
GLfloat gl_lightViewProjMatrix[16];
|
|
pl->lightviewProjMatrix.CopyToArray( gl_lightViewProjMatrix );
|
|
u->SetValue( &gl_lightViewProjMatrix[0] );
|
|
}
|
|
break;
|
|
case UT_DIFFUSEFACTOR:
|
|
u->SetValue( tr.diffuseFactor );
|
|
break;
|
|
case UT_AMBIENTFACTOR:
|
|
if( pl && pl->type == LIGHT_DIRECTIONAL )
|
|
u->SetValue( tr.sun_ambient );
|
|
else u->SetValue( tr.ambientFactor );
|
|
break;
|
|
case UT_SUNREFRACT:
|
|
u->SetValue( tr.sun_refract );
|
|
break;
|
|
case UT_LIGHTNUMS0:
|
|
u->SetValue( (float)grass->lights[0], (float)grass->lights[1], (float)grass->lights[2], (float)grass->lights[3] );
|
|
break;
|
|
case UT_LIGHTNUMS1:
|
|
u->SetValue( (float)grass->lights[4], (float)grass->lights[5], (float)grass->lights[6], (float)grass->lights[7] );
|
|
break;
|
|
case UT_GRASSPARAMS:
|
|
u->SetValue( m_flGrassFadeStart, m_flGrassFadeDist, m_flGrassFadeEnd );
|
|
break;
|
|
default:
|
|
ALERT( at_error, "%s: unhandled uniform %s\n", RI->currentshader->name, u->name );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_SortGrassMeshes
|
|
|
|
sort by texture
|
|
=================
|
|
*/
|
|
static int R_SortGrassMeshes( struct grass_s *const *pa, struct grass_s *const *pb )
|
|
{
|
|
grass_t *a = (grass_t *)*pa;
|
|
grass_t *b = (grass_t *)*pb;
|
|
|
|
if( a->texture > b->texture )
|
|
return -1;
|
|
if( a->texture < b->texture )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_RenderGrassOnList
|
|
|
|
rendering the grass
|
|
================
|
|
*/
|
|
void R_RenderGrassOnList( void )
|
|
{
|
|
word hCachedMatrix = -1;
|
|
word hLastShader = -1;
|
|
word hCurrentShader;
|
|
byte hLastTexture = -1;
|
|
byte cached_lights[MAXDYNLIGHTS] = { 255 };
|
|
bool update_params = false;
|
|
int parms_updated = 0;
|
|
|
|
if( !RI->frame.grass_list.Count())
|
|
return; // don't waste time
|
|
|
|
if( !FBitSet( RI->params, RP_DEFERREDLIGHT ))
|
|
GL_AlphaTest( GL_TRUE );
|
|
else GL_AlphaTest( GL_FALSE );
|
|
pglAlphaFunc( GL_GREATER, r_grass_alpha->value );
|
|
GL_Cull( GL_NONE ); // grass is double-sided poly
|
|
GL_DepthMask( GL_TRUE );
|
|
GL_Blend( GL_FALSE );
|
|
|
|
// sorting list to reduce shader switches
|
|
if( !CVAR_TO_BOOL( cv_nosort ))
|
|
RI->frame.grass_list.Sort( R_SortGrassMeshes );
|
|
|
|
for( int i = 0; i < RI->frame.grass_list.Count(); i++ )
|
|
{
|
|
grass_t *g = RI->frame.grass_list[i];
|
|
|
|
if( FBitSet( RI->params, RP_DEFERREDSCENE ))
|
|
hCurrentShader = g->deferredScene.GetHandle();
|
|
else if( FBitSet( RI->params, RP_DEFERREDLIGHT ))
|
|
hCurrentShader = g->deferredLight.GetHandle();
|
|
else hCurrentShader = g->forwardScene.GetHandle();
|
|
|
|
if( !hCurrentShader ) continue;
|
|
|
|
if( FBitSet( RI->params, RP_DEFERREDSCENE|RP_DEFERREDLIGHT ) && memcmp( g->lights, cached_lights, MAXDYNLIGHTS ))
|
|
{
|
|
memcpy( cached_lights, g->lights, MAXDYNLIGHTS );
|
|
update_params = true;
|
|
}
|
|
|
|
if( hCachedMatrix != g->hCachedMatrix )
|
|
{
|
|
hCachedMatrix = g->hCachedMatrix;
|
|
update_params = true;
|
|
}
|
|
|
|
if( FBitSet( g->flags, FRGASS_SKYENTITY ))
|
|
{
|
|
GL_DepthRange( 0.8f, 0.9f );
|
|
GL_ClipPlane( false );
|
|
}
|
|
else
|
|
{
|
|
GL_DepthRange( gldepthmin, gldepthmax );
|
|
GL_ClipPlane( true );
|
|
}
|
|
|
|
if( hLastShader != hCurrentShader )
|
|
{
|
|
hLastShader = hCurrentShader;
|
|
update_params = true;
|
|
}
|
|
|
|
if( hLastTexture != g->texture )
|
|
{
|
|
hLastTexture = g->texture;
|
|
update_params = true;
|
|
}
|
|
|
|
if( update_params )
|
|
{
|
|
R_SetGrassUniforms( hCurrentShader, g );
|
|
update_params = false;
|
|
}
|
|
|
|
R_DrawGrassMeshFromBuffer( g );
|
|
}
|
|
|
|
// restore old binding
|
|
GL_DepthRange( gldepthmin, gldepthmax );
|
|
GL_ClipPlane( true );
|
|
GL_Cull( GL_FRONT );
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_DrawLightForGrass
|
|
|
|
draw lighting for grass
|
|
================
|
|
*/
|
|
void R_DrawLightForGrass( CDynLight *pl )
|
|
{
|
|
word hCachedMatrix = -1;
|
|
word hLastShader = -1;
|
|
byte hLastTexture = -1;
|
|
bool update_params = false;
|
|
word hLightShader;
|
|
|
|
if( !RI->frame.light_grass.Count())
|
|
return; // don't waste time
|
|
|
|
GL_AlphaTest( GL_TRUE );
|
|
pglAlphaFunc( GL_GREATER, r_grass_alpha->value );
|
|
GL_Cull( GL_NONE );
|
|
|
|
// sorting list to reduce shader switches
|
|
if( !CVAR_TO_BOOL( cv_nosort ))
|
|
RI->frame.light_grass.Sort( R_SortGrassMeshes );
|
|
|
|
for( int i = 0; i < RI->frame.light_grass.Count(); i++ )
|
|
{
|
|
grass_t *g = RI->frame.light_grass[i];
|
|
|
|
switch( pl->type )
|
|
{
|
|
case LIGHT_SPOT:
|
|
hLightShader = g->forwardLightSpot.GetHandle();
|
|
break;
|
|
case LIGHT_OMNI:
|
|
hLightShader = g->forwardLightOmni.GetHandle();
|
|
break;
|
|
case LIGHT_DIRECTIONAL:
|
|
hLightShader = g->forwardLightProj.GetHandle();
|
|
break;
|
|
default:
|
|
hLightShader = 0;
|
|
break;
|
|
}
|
|
|
|
if( !hLightShader ) continue;
|
|
|
|
if( hCachedMatrix != g->hCachedMatrix )
|
|
{
|
|
hCachedMatrix = g->hCachedMatrix;
|
|
update_params = true;
|
|
}
|
|
|
|
if( hLastShader != hLightShader )
|
|
{
|
|
hLastShader = hLightShader;
|
|
update_params = true;
|
|
}
|
|
|
|
if( hLastTexture != g->texture )
|
|
{
|
|
hLastTexture = g->texture;
|
|
update_params = true;
|
|
}
|
|
|
|
if( update_params )
|
|
{
|
|
R_SetGrassUniforms( hLightShader, g );
|
|
update_params = false;
|
|
}
|
|
|
|
R_DrawGrassMeshFromBuffer( g );
|
|
}
|
|
|
|
GL_Cull( GL_FRONT );
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_RenderShadowGrassOnList
|
|
|
|
depth pass
|
|
================
|
|
*/
|
|
void R_RenderShadowGrassOnList( void )
|
|
{
|
|
word hCachedMatrix = -1;
|
|
word hLastShader = -1;
|
|
byte hLastTexture = -1;
|
|
bool update_params = false;
|
|
|
|
if( !RI->frame.grass_list.Count())
|
|
return; // don't waste time
|
|
|
|
GL_AlphaTest( GL_TRUE );
|
|
pglAlphaFunc( GL_GREATER, r_grass_alpha->value );
|
|
GL_Cull( GL_NONE ); // grass is double-sided poly
|
|
|
|
// sorting list to reduce shader switches
|
|
if( !CVAR_TO_BOOL( cv_nosort ))
|
|
RI->frame.grass_list.Sort( R_SortGrassMeshes );
|
|
|
|
for( int i = 0; i < RI->frame.grass_list.Count(); i++ )
|
|
{
|
|
grass_t *g = RI->frame.grass_list[i];
|
|
|
|
if( hCachedMatrix != g->hCachedMatrix )
|
|
{
|
|
hCachedMatrix = g->hCachedMatrix;
|
|
update_params = true;
|
|
}
|
|
|
|
if( hLastShader != g->forwardDepth.GetHandle() )
|
|
{
|
|
hLastShader = g->forwardDepth.GetHandle();
|
|
update_params = true;
|
|
}
|
|
|
|
if( hLastTexture != g->texture )
|
|
{
|
|
hLastTexture = g->texture;
|
|
update_params = true;
|
|
}
|
|
|
|
if( update_params )
|
|
{
|
|
R_SetGrassUniforms( g->forwardDepth.GetHandle(), g );
|
|
update_params = false;
|
|
}
|
|
|
|
R_DrawGrassMeshFromBuffer( g );
|
|
}
|
|
|
|
// restore old binding
|
|
GL_Cull( GL_FRONT );
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassTextureForName
|
|
|
|
find or add unique texture for grass
|
|
================
|
|
*/
|
|
byte R_GrassTextureForName( const char *name )
|
|
{
|
|
for( byte i = 0; i < GRASS_TEXTURES && grasstexs[i].name[0]; i++ )
|
|
{
|
|
if( !Q_stricmp( grasstexs[i].name, name ))
|
|
return i; // found
|
|
}
|
|
|
|
// allocate a new one
|
|
Q_strncpy( grasstexs[i].name, name, sizeof( grasstexs[i].name ));
|
|
grasstexs[i].gl_texturenum = LOAD_TEXTURE( name, NULL, 0, TF_GRASS );
|
|
|
|
if( !grasstexs[i].gl_texturenum )
|
|
{
|
|
ALERT( at_warning, "couldn't load %s\n", name );
|
|
grasstexs[i].gl_texturenum = tr.defaultTexture;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassInitForSurface
|
|
|
|
lookup all the descriptions
|
|
because this system allow many
|
|
sorts of grass per one surface
|
|
================
|
|
*/
|
|
void R_GrassInitForSurface( msurface_t *surf )
|
|
{
|
|
if( !surf || !surf->texinfo || !surf->texinfo->texture )
|
|
return; // some bad polygons
|
|
|
|
mextrasurf_t *es = surf->info;
|
|
bvert_t *v0, *v1, *v2;
|
|
|
|
for( int i = 0; i < grassInfo.Count(); i++ )
|
|
{
|
|
grassentry_t *entry = &grassInfo[i];
|
|
|
|
if( !Mod_CheckLayerNameForSurf( surf, entry->name ))
|
|
continue;
|
|
|
|
if( !FBitSet( surf->flags, SURF_PLANEBACK ) && surf->plane->normal.z < 0.40f )
|
|
continue; // vertical too much
|
|
|
|
if( FBitSet( surf->flags, SURF_PLANEBACK ) && surf->plane->normal.z > -0.40f )
|
|
continue; // vertical too much
|
|
|
|
// turn the face into a bunch of polygons, and compute the area of each
|
|
v0 = &world->vertexes[es->firstvertex];
|
|
int count = 0;
|
|
|
|
for( int j = 1; j < es->numverts - 1; j++ )
|
|
{
|
|
v1 = &world->vertexes[es->firstvertex+j];
|
|
v2 = &world->vertexes[es->firstvertex+j+1];
|
|
|
|
// compute two triangle edges
|
|
Vector e1 = v1->vertex - v0->vertex;
|
|
Vector e2 = v2->vertex - v0->vertex;
|
|
|
|
// compute the triangle area
|
|
Vector areaVec = CrossProduct( e1, e2 );
|
|
float normalLength = areaVec.Length();
|
|
float area = 0.5f * normalLength;
|
|
|
|
// compute the number of samples to take
|
|
count += area * entry->density * DENSITY_FACTOR;
|
|
}
|
|
|
|
if( count ) es->grasscount++; // mesh added
|
|
|
|
if( es->grasscount > 0 ) // at least one bush was detected
|
|
SetBits( world->features, WORLD_HAS_GRASS );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassSetupFrame
|
|
|
|
clear the chains
|
|
================
|
|
*/
|
|
void R_GrassSetupFrame( void )
|
|
{
|
|
m_flGrassFadeStart = r_grass_fade_start->value;
|
|
|
|
if( m_flGrassFadeStart < GRASS_ANIM_DIST )
|
|
m_flGrassFadeStart = GRASS_ANIM_DIST;
|
|
m_flGrassFadeDist = max( 0.0f, r_grass_fade_dist->value );
|
|
m_flGrassFadeEnd = m_flGrassFadeStart + m_flGrassFadeDist;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassShaderSceneForward
|
|
|
|
compute albedo with static lighting
|
|
================
|
|
*/
|
|
static word R_GrassShaderSceneForward( msurface_t *s, grass_t *g )
|
|
{
|
|
char glname[64];
|
|
char options[MAX_OPTIONS_LENGTH];
|
|
mextrasurf_t *es = s->info;
|
|
|
|
if( g->forwardScene.IsValid( ))
|
|
return g->forwardScene.GetHandle(); // valid
|
|
|
|
ASSERT( RI->currententity != NULL );
|
|
|
|
Q_strncpy( glname, "forward/scene_grass", sizeof( glname ));
|
|
memset( options, 0, sizeof( options ));
|
|
|
|
material_t *mat = R_TextureAnimation( s )->material;
|
|
|
|
if( FBitSet( mat->flags, BRUSH_FULLBRIGHT ) || R_FullBright( ))
|
|
{
|
|
GL_AddShaderDirective( options, "LIGHTING_FULLBRIGHT" );
|
|
}
|
|
else
|
|
{
|
|
if( r_lightmap->value > 0.0f && r_lightmap->value <= 2.0f )
|
|
{
|
|
if( r_lightmap->value == 1.0f && worldmodel->lightdata )
|
|
GL_AddShaderDirective( options, "LIGHTMAP_DEBUG" );
|
|
else if( r_lightmap->value == 2.0f && FBitSet( world->features, WORLD_HAS_DELUXEMAP ))
|
|
GL_AddShaderDirective( options, "LIGHTVEC_DEBUG" );
|
|
}
|
|
|
|
if( es->normals != NULL && r_grass->value > 1.0f )
|
|
GL_AddShaderDirective( options, "HAS_DELUXEMAP" );
|
|
|
|
// process lightstyles
|
|
for( int i = 0; i < MAXLIGHTMAPS && s->styles[i] != LS_NONE; i++ )
|
|
GL_AddShaderDirective( options, va( "APPLY_STYLE%i", i ));
|
|
}
|
|
|
|
if( RI->currententity->curstate.renderfx != SKYBOX_ENTITY )
|
|
GL_AddShaderDirective( options, "APPLY_FADE_DIST" );
|
|
|
|
if( tr.fogEnabled )
|
|
GL_AddShaderDirective( options, "APPLY_FOG_EXP" );
|
|
|
|
word shaderNum = GL_FindUberShader( glname, options );
|
|
if( !shaderNum )
|
|
{
|
|
SetBits( g->flags, FGRASS_NODRAW );
|
|
return 0; // something bad happens
|
|
}
|
|
|
|
g->forwardScene.SetShader( shaderNum );
|
|
ClearBits( g->flags, FGRASS_NODRAW );
|
|
|
|
return shaderNum;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassShaderLightForward
|
|
|
|
compute dynamic lighting
|
|
================
|
|
*/
|
|
static word R_GrassShaderLightForward( CDynLight *dl, grass_t *g )
|
|
{
|
|
char glname[64];
|
|
char options[MAX_OPTIONS_LENGTH];
|
|
|
|
switch( dl->type )
|
|
{
|
|
case LIGHT_SPOT:
|
|
if( g->forwardLightSpot.IsValid( ))
|
|
return g->forwardLightSpot.GetHandle(); // valid
|
|
break;
|
|
case LIGHT_OMNI:
|
|
if( g->forwardLightOmni.IsValid( ))
|
|
return g->forwardLightOmni.GetHandle(); // valid
|
|
break;
|
|
case LIGHT_DIRECTIONAL:
|
|
if( g->forwardLightProj.IsValid( ))
|
|
return g->forwardLightProj.GetHandle(); // valid
|
|
break;
|
|
}
|
|
|
|
Q_strncpy( glname, "forward/light_grass", sizeof( glname ));
|
|
memset( options, 0, sizeof( options ));
|
|
|
|
switch( dl->type )
|
|
{
|
|
case LIGHT_SPOT:
|
|
GL_AddShaderDirective( options, "LIGHT_SPOT" );
|
|
break;
|
|
case LIGHT_OMNI:
|
|
GL_AddShaderDirective( options, "LIGHT_OMNI" );
|
|
break;
|
|
case LIGHT_DIRECTIONAL:
|
|
GL_AddShaderDirective( options, "LIGHT_PROJ" );
|
|
break;
|
|
}
|
|
|
|
if( RI->currententity->curstate.renderfx != SKYBOX_ENTITY )
|
|
GL_AddShaderDirective( options, "APPLY_FADE_DIST" );
|
|
|
|
if( CVAR_TO_BOOL( r_shadows ) && !FBitSet( dl->flags, DLF_NOSHADOWS ))
|
|
{
|
|
// shadow cubemaps only support if GL_EXT_gpu_shader4 is support
|
|
if( dl->type == LIGHT_DIRECTIONAL && CVAR_TO_BOOL( r_sunshadows ))
|
|
GL_AddShaderDirective( options, "APPLY_SHADOW" );
|
|
else if( dl->type == LIGHT_SPOT || GL_Support( R_EXT_GPU_SHADER4 ))
|
|
GL_AddShaderDirective( options, "APPLY_SHADOW" );
|
|
}
|
|
|
|
word shaderNum = GL_FindUberShader( glname, options );
|
|
|
|
if( !shaderNum )
|
|
{
|
|
if( dl->type == LIGHT_DIRECTIONAL )
|
|
SetBits( g->flags, FGRASS_NOSUNLIGHT );
|
|
else SetBits( g->flags, FGRASS_NODLIGHT );
|
|
return 0; // something bad happens
|
|
}
|
|
|
|
// done
|
|
switch( dl->type )
|
|
{
|
|
case LIGHT_SPOT:
|
|
g->forwardLightSpot.SetShader( shaderNum );
|
|
ClearBits( g->flags, FGRASS_NODLIGHT );
|
|
break;
|
|
case LIGHT_OMNI:
|
|
g->forwardLightOmni.SetShader( shaderNum );
|
|
ClearBits( g->flags, FGRASS_NODLIGHT );
|
|
break;
|
|
case LIGHT_DIRECTIONAL:
|
|
g->forwardLightProj.SetShader( shaderNum );
|
|
ClearBits( g->flags, FGRASS_NOSUNLIGHT );
|
|
break;
|
|
}
|
|
|
|
return shaderNum;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassShaderSceneDeferred
|
|
|
|
grass scene deferred
|
|
================
|
|
*/
|
|
word R_GrassShaderSceneDeferred( msurface_t *s, grass_t *g )
|
|
{
|
|
char glname[64];
|
|
char options[MAX_OPTIONS_LENGTH];
|
|
mextrasurf_t *es = s->info;
|
|
|
|
if( g->deferredScene.IsValid( ))
|
|
return g->deferredScene.GetHandle(); // valid
|
|
|
|
Q_strncpy( glname, "deferred/scene_grass", sizeof( glname ));
|
|
memset( options, 0, sizeof( options ));
|
|
|
|
material_t *mat = s->texinfo->texture->material;
|
|
|
|
if( RI->currententity->curstate.renderfx != SKYBOX_ENTITY )
|
|
GL_AddShaderDirective( options, "APPLY_FADE_DIST" );
|
|
|
|
word shaderNum = GL_FindUberShader( glname, options );
|
|
if( !shaderNum )
|
|
{
|
|
SetBits( g->flags, FGRASS_NODRAW );
|
|
return 0; // something bad happens
|
|
}
|
|
|
|
ClearBits( g->flags, FGRASS_NODRAW );
|
|
g->deferredScene.SetShader( shaderNum );
|
|
|
|
return shaderNum;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassShaderLightDeferred
|
|
|
|
grass light deferred
|
|
================
|
|
*/
|
|
word R_GrassShaderLightDeferred( msurface_t *s, grass_t *g )
|
|
{
|
|
char glname[64];
|
|
char options[MAX_OPTIONS_LENGTH];
|
|
mextrasurf_t *es = s->info;
|
|
|
|
if( g->deferredLight.IsValid( ))
|
|
return g->deferredLight.GetHandle(); // valid
|
|
|
|
Q_strncpy( glname, "deferred/light_grass", sizeof( glname ));
|
|
memset( options, 0, sizeof( options ));
|
|
|
|
material_t *mat = s->texinfo->texture->material;
|
|
|
|
if( RI->currententity->curstate.renderfx != SKYBOX_ENTITY )
|
|
GL_AddShaderDirective( options, "APPLY_FADE_DIST" );
|
|
|
|
word shaderNum = GL_FindUberShader( glname, options );
|
|
if( !shaderNum )
|
|
{
|
|
SetBits( g->flags, FGRASS_NODRAW );
|
|
return 0; // something bad happens
|
|
}
|
|
|
|
g->deferredLight.SetShader( shaderNum );
|
|
ClearBits( g->flags, FGRASS_NODRAW );
|
|
|
|
return shaderNum;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassShaderSceneDepth
|
|
|
|
return grass depth-shader
|
|
================
|
|
*/
|
|
static word R_GrassShaderSceneDepth( msurface_t *s, grass_t *g )
|
|
{
|
|
char glname[64];
|
|
char options[MAX_OPTIONS_LENGTH];
|
|
mextrasurf_t *es = s->info;
|
|
|
|
if( g->forwardDepth.IsValid( ))
|
|
return g->forwardDepth.GetHandle(); // valid
|
|
|
|
ASSERT( RI->currententity != NULL );
|
|
|
|
Q_strncpy( glname, "forward/depth_grass", sizeof( glname ));
|
|
memset( options, 0, sizeof( options ));
|
|
|
|
if( RI->currententity->curstate.renderfx != SKYBOX_ENTITY )
|
|
GL_AddShaderDirective( options, "APPLY_FADE_DIST" );
|
|
|
|
word shaderNum = GL_FindUberShader( glname, options );
|
|
if( !shaderNum ) return 0; // something bad happens
|
|
|
|
g->forwardDepth.SetShader( shaderNum );
|
|
|
|
return shaderNum;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_PrecacheGrass
|
|
|
|
precache grass in the world
|
|
================
|
|
*/
|
|
void R_PrecacheGrass( msurface_t *s, mextraleaf_t *leaf )
|
|
{
|
|
mextrasurf_t *es = s->info;
|
|
grasshdr_t *hdr = es->grass;
|
|
cl_entity_t *e = GET_ENTITY( 0 );
|
|
|
|
if( !es->grasscount ) return; // no grass for this face
|
|
|
|
if( hdr )
|
|
{
|
|
if( FBitSet( s->flags, SURF_GRASS_UPDATE ))
|
|
{
|
|
// rebuild mesh with new gamma
|
|
R_RemoveGrassForSurface( es );
|
|
}
|
|
else
|
|
{
|
|
// already created?
|
|
return;
|
|
}
|
|
}
|
|
|
|
float curdist = VectorDistance( tr.cached_vieworigin, es->origin );
|
|
|
|
// but grass that attached to sky entities will be ignoring distance
|
|
if( curdist > m_flGrassFadeEnd && ( e->curstate.renderfx != SKYBOX_ENTITY ))
|
|
return; // too far
|
|
|
|
// initialize grass for surface
|
|
R_ConstructGrassForSurface( s, es );
|
|
hdr = es->grass; // refresh the pointer
|
|
|
|
if( hdr && leaf )
|
|
{
|
|
// prevent to expand leafs too much
|
|
AddPointToBounds( hdr->mins, leaf->mins, leaf->maxs, LEAF_MAX_EXPAND );
|
|
AddPointToBounds( hdr->maxs, leaf->mins, leaf->maxs, LEAF_MAX_EXPAND );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_AddGrassToDrawList
|
|
|
|
build the visible grass list
|
|
================
|
|
*/
|
|
void R_AddGrassToDrawList( msurface_t *s, drawlist_t drawlist_type )
|
|
{
|
|
if( !FBitSet( world->features, WORLD_HAS_GRASS ))
|
|
return; // completely has no grass
|
|
|
|
if( !CVAR_TO_BOOL( r_grass ) || FBitSet( RI->params, RP_NOGRASS ))
|
|
return; // disabled by request
|
|
|
|
if( drawlist_type == DRAWLIST_SHADOW && !CVAR_TO_BOOL( r_grass_shadows ))
|
|
return;// don't cast shadows from grass
|
|
|
|
if( drawlist_type == DRAWLIST_LIGHT && !CVAR_TO_BOOL( r_grass_lighting ))
|
|
return;// don't cast shadows from grass
|
|
|
|
mextrasurf_t *es = s->info;
|
|
cl_entity_t *e = es->parent;
|
|
Vector absmin, absmax;
|
|
|
|
// do simple culling by distance
|
|
if( es->grasscount <= 0 ) return; // surface doesn't contain grass
|
|
float curdist = VectorDistance( es->origin, tr.cached_vieworigin );
|
|
|
|
// but grass that attached to sky entities will be ignoring distance
|
|
if( curdist > m_flGrassFadeEnd && ( e->curstate.renderfx != SKYBOX_ENTITY ))
|
|
return; // too far
|
|
|
|
// rebuild mesh with new gamma
|
|
if( es->grass && FBitSet( s->flags, SURF_GRASS_UPDATE ))
|
|
R_RemoveGrassForSurface( es );
|
|
|
|
if( !es->grass && RP_NORMALPASS( ))
|
|
R_ConstructGrassForSurface( s, es );
|
|
|
|
grasshdr_t *hdr = es->grass;
|
|
if( !hdr ) return; // face completely missed grass or creation was failed
|
|
|
|
gl_state_t *glm = GL_GetCache( e->hCachedMatrix );
|
|
|
|
if( e->hCachedMatrix == WORLD_MATRIX )
|
|
{
|
|
// default case
|
|
absmin = hdr->mins;
|
|
absmax = hdr->maxs;
|
|
}
|
|
else
|
|
{
|
|
// moving entity
|
|
TransformAABB( glm->transform, hdr->mins, hdr->maxs, absmin, absmax );
|
|
}
|
|
|
|
CFrustum *frustum = NULL;
|
|
|
|
if( RI->currentlight != NULL )
|
|
frustum = &RI->currentlight->frustum;
|
|
else frustum = &RI->view.frustum;
|
|
|
|
if( frustum && frustum->CullBox( absmin, absmax ))
|
|
return;
|
|
|
|
// NOTE: at this point we have surface that passed visibility and frustum tests
|
|
|
|
// each mesh should be added individually
|
|
for( int i = 0; i < hdr->count; i++ )
|
|
{
|
|
grass_t *grass = &hdr->g[i];
|
|
|
|
if( e->curstate.renderfx == SKYBOX_ENTITY )
|
|
SetBits( grass->flags, FRGASS_SKYENTITY );
|
|
else ClearBits( grass->flags, FRGASS_SKYENTITY );
|
|
grass->hCachedMatrix = e->hCachedMatrix;
|
|
|
|
switch( drawlist_type )
|
|
{
|
|
case DRAWLIST_SOLID:
|
|
if( FBitSet( grass->flags, FGRASS_NODRAW ))
|
|
continue;
|
|
if( FBitSet( RI->params, RP_DEFERREDSCENE|RP_DEFERREDLIGHT ))
|
|
{
|
|
// precache shaders
|
|
R_GrassShaderSceneDeferred( s, grass );
|
|
R_GrassShaderLightDeferred( s, grass );
|
|
}
|
|
else R_GrassShaderSceneForward( s, grass );
|
|
RI->frame.grass_list.AddToTail( grass );
|
|
break;
|
|
case DRAWLIST_SHADOW:
|
|
if( FBitSet( grass->flags, FGRASS_NODRAW ))
|
|
continue;
|
|
R_GrassShaderSceneDepth( s, grass );
|
|
RI->frame.grass_list.AddToTail( grass );
|
|
break;
|
|
case DRAWLIST_LIGHT:
|
|
if( RI->currentlight->type == LIGHT_DIRECTIONAL )
|
|
{
|
|
if( FBitSet( grass->flags, FGRASS_NOSUNLIGHT ))
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if( FBitSet( grass->flags, FGRASS_NODLIGHT ))
|
|
continue;
|
|
}
|
|
R_GrassShaderLightForward( RI->currentlight, grass );
|
|
RI->frame.light_grass.AddToTail( grass );
|
|
break;
|
|
default: // invalid mode
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_UnloadFarGrass
|
|
|
|
release far VBO's
|
|
================
|
|
*/
|
|
void R_UnloadFarGrass( void )
|
|
{
|
|
if( !FBitSet( world->features, WORLD_HAS_GRASS ))
|
|
return; // don't waste time
|
|
|
|
if( ++tr.grassunloadframe < 300 )
|
|
return; // run every three seconds
|
|
|
|
// check surfaces
|
|
for( int i = 0; i < worldmodel->numsurfaces; i++ )
|
|
{
|
|
msurface_t *surf = &worldmodel->surfaces[i];
|
|
mextrasurf_t *es = surf->info;
|
|
|
|
if( !es->grasscount ) continue; // surface doesn't contain grass
|
|
float curdist = VectorDistance( tr.cached_vieworigin, es->origin );
|
|
|
|
if( curdist > m_flGrassFadeEnd )
|
|
{
|
|
if( curdist > ( m_flGrassFadeEnd * 2.0f ) && es->grass )
|
|
R_RemoveGrassForSurface( es );
|
|
}
|
|
}
|
|
|
|
tr.grassunloadframe = 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassInit
|
|
|
|
parse grass definitions and load textures
|
|
================
|
|
*/
|
|
void R_GrassInit( void )
|
|
{
|
|
static int random_seed = 1; // starts from 1
|
|
|
|
char *afile = (char *)gEngfuncs.COM_LoadFile( "gfx/grass/grassinfo.txt", 5, NULL );
|
|
if( !afile ) ALERT( at_error, "couldn't load grassinfo.txt\n" );
|
|
|
|
// remove grass description from the pervious map
|
|
grassInfo.Purge();
|
|
|
|
memset( grasstexs, 0, sizeof( grasstexs ));
|
|
|
|
if( afile )
|
|
{
|
|
grassentry_t entry;
|
|
char *pfile = afile;
|
|
int parse_line = 1;
|
|
char token[1024];
|
|
|
|
while(( pfile = COM_ParseFile( pfile, token )) != NULL )
|
|
{
|
|
Q_strncpy( entry.name, token, sizeof( entry.name ));
|
|
|
|
pfile = COM_ParseLine( pfile, token );
|
|
if( !pfile )
|
|
{
|
|
ALERT( at_error, "R_GrassInit: missed grass texture path at line %i\n", parse_line );
|
|
parse_line++;
|
|
continue;
|
|
}
|
|
|
|
entry.texture = R_GrassTextureForName( token );
|
|
|
|
pfile = COM_ParseLine( pfile, token );
|
|
if( !pfile )
|
|
{
|
|
ALERT( at_error, "R_GrassInit: missed grass density at line %i\n", parse_line );
|
|
parse_line++;
|
|
continue;
|
|
}
|
|
entry.density = Q_atof( token );
|
|
entry.density = bound( 0.1f, entry.density, 512.0f );
|
|
|
|
pfile = COM_ParseLine( pfile, token );
|
|
if( !pfile )
|
|
{
|
|
ALERT( at_error, "R_GrassInit: missed grass min scale at line %i\n", parse_line );
|
|
parse_line++;
|
|
continue;
|
|
}
|
|
entry.min = Q_atof( token );
|
|
entry.min = bound( 0.01f, entry.min, 100.0f );
|
|
|
|
pfile = COM_ParseLine( pfile, token );
|
|
if( !pfile )
|
|
{
|
|
ALERT( at_error, "R_GrassInit: missed grass max scale at line %i\n", parse_line );
|
|
parse_line++;
|
|
continue;
|
|
}
|
|
entry.max = Q_atof( token );
|
|
entry.max = bound( entry.min, entry.max, 100.0f );
|
|
if( entry.min > entry.max ) entry.min = entry.max;
|
|
|
|
pfile = COM_ParseLine( pfile, token );
|
|
if( pfile )
|
|
{
|
|
// seed is optional
|
|
entry.seed = Q_atoi( token );
|
|
entry.seed = max( 1, entry.seed );
|
|
}
|
|
else entry.seed = random_seed++;
|
|
|
|
grassInfo.AddToTail( entry );
|
|
parse_line++;
|
|
}
|
|
|
|
gEngfuncs.COM_FreeFile( afile );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_GrassShutdown
|
|
|
|
prepare grass system to shutdown
|
|
================
|
|
*/
|
|
void R_GrassShutdown( void )
|
|
{
|
|
// release all grass textures
|
|
for( int i = 0; i < GRASS_TEXTURES; i++ )
|
|
{
|
|
if( !grasstexs[i].gl_texturenum )
|
|
continue;
|
|
|
|
FREE_TEXTURE( grasstexs[i].gl_texturenum );
|
|
}
|
|
} |