vk_rsurf.c File Reference

#include <assert.h>
#include "vk_local.h"

Go to the source code of this file.

Classes
struct	vklightmapstate_t

Macros
#define	DYNAMIC_LIGHT_WIDTH   128
#define	DYNAMIC_LIGHT_HEIGHT   128
#define	LIGHTMAP_BYTES   4
#define	BLOCK_WIDTH   128
#define	BLOCK_HEIGHT   128

Functions
static void	LM_InitBlock (void)
static void	LM_UploadBlock (qboolean dynamic)
static qboolean	LM_AllocBlock (int w, int h, int *x, int *y)
void	R_SetCacheState (msurface_t *surf)
void	R_BuildLightMap (msurface_t *surf, byte *dest, int stride)
image_t *	R_TextureAnimation (mtexinfo_t *tex)
void	DrawVkPoly (vkpoly_t *p, image_t *texture, float *color)
void	DrawVkFlowingPoly (msurface_t *fa, image_t *texture, float *color)
void	R_DrawTriangleOutlines (void)
void	R_RenderBrushPoly (msurface_t *fa, float *modelMatrix, float alpha)
void	R_DrawAlphaSurfaces (void)
void	DrawTextureChains (void)
static void	Vk_RenderLightmappedPoly (msurface_t *surf, float *modelMatrix, float alpha)
void	R_DrawInlineBModel (float *modelMatrix)
void	R_DrawBrushModel (entity_t *e)
void	R_RecursiveWorldNode (mnode_t *node)
void	R_DrawWorld (void)
void	R_MarkLeaves (void)
void	Vk_BuildPolygonFromSurface (msurface_t *fa)
void	Vk_CreateSurfaceLightmap (msurface_t *surf)
void	Vk_BeginBuildingLightmaps (model_t *m)
void	Vk_EndBuildingLightmaps (void)

Variables
static vec3_t	modelorg
msurface_t *	r_alpha_surfaces
int	c_visible_lightmaps
int	c_visible_textures
static vklightmapstate_t	vk_lms

Macro Definition Documentation

BLOCK_HEIGHT

#define BLOCK_HEIGHT   128

Definition at line 36 of file vk_rsurf.c.

BLOCK_WIDTH

#define BLOCK_WIDTH   128

Definition at line 35 of file vk_rsurf.c.

DYNAMIC_LIGHT_HEIGHT

#define DYNAMIC_LIGHT_HEIGHT   128

Definition at line 31 of file vk_rsurf.c.

DYNAMIC_LIGHT_WIDTH

#define DYNAMIC_LIGHT_WIDTH   128

Definition at line 30 of file vk_rsurf.c.

LIGHTMAP_BYTES

#define LIGHTMAP_BYTES   4

Definition at line 33 of file vk_rsurf.c.

Function Documentation

DrawTextureChains()

void DrawTextureChains

(

void

)

Definition at line 396 of file vk_rsurf.c.

{
    int     i;
    msurface_t  *s;
    image_t     *image;
 
    c_visible_textures = 0;
 
    for (i = 0, image = vktextures; i < numvktextures; i++, image++)
    {
        if (!image->registration_sequence)
            continue;
        if (!image->texturechain)
            continue;
        c_visible_textures++;
 
        for (s = image->texturechain; s; s = s->texturechain)
        {
            if (!(s->flags & SURF_DRAWTURB))
                R_RenderBrushPoly(s, NULL, 1.f);
        }
    }
 
    for (i = 0, image = vktextures; i < numvktextures; i++, image++)
    {
        if (!image->registration_sequence)
            continue;
        s = image->texturechain;
        if (!s)
            continue;
 
        for (; s; s = s->texturechain)
        {
            if (s->flags & SURF_DRAWTURB)
                R_RenderBrushPoly(s, NULL, 1.f);
        }
 
        image->texturechain = NULL;
    }
}

Referenced by R_DrawWorld().

DrawVkFlowingPoly()

void DrawVkFlowingPoly	(	msurface_t *	fa,
		image_t *	texture,
		float *	color
	)

Definition at line 148 of file vk_rsurf.c.

{
    int     i;
    float   *v;
    vkpoly_t *p;
    float   scroll;
 
    typedef struct {
        float vertex[3];
        float texCoord[2];
    } polyvert;
 
    static polyvert verts[MAX_VERTS];
 
    p = fa->polys;
 
    scroll = -64 * ((r_newrefdef.time / 40.0) - (int)(r_newrefdef.time / 40.0));
    if (scroll == 0.0)
        scroll = -64.0;
 
    v = p->verts[0];
    for (i = 0; i < p->numverts; i++, v += VERTEXSIZE)
    {
        verts[i].vertex[0] = v[0];
        verts[i].vertex[1] = v[1];
        verts[i].vertex[2] = v[2];
        verts[i].texCoord[0] = v[3] + scroll;
        verts[i].texCoord[1] = v[4];
    }
 
    QVk_BindPipeline(&vk_drawPolyPipeline);
 
    VkBuffer vbo;
    VkDeviceSize vboOffset;
    uint32_t uboOffset;
    VkDescriptorSet uboDescriptorSet;
    uint8_t *vertData = QVk_GetVertexBuffer(sizeof(polyvert) * p->numverts, &vbo, &vboOffset);
    uint8_t *uboData  = QVk_GetUniformBuffer(sizeof(float) * 4, &uboOffset, &uboDescriptorSet);
    memcpy(vertData, verts, sizeof(polyvert) * p->numverts);
    memcpy(uboData,  color, sizeof(float) * 4);
 
    VkDescriptorSet descriptorSets[] = { texture->vk_texture.descriptorSet, uboDescriptorSet };
    vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_drawPolyPipeline.layout, 0, 2, descriptorSets, 1, &uboOffset);
    vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vbo, &vboOffset);
    vkCmdBindIndexBuffer(vk_activeCmdbuffer, QVk_GetTriangleFanIbo((p->numverts - 2) * 3), 0, VK_INDEX_TYPE_UINT16);
    vkCmdDrawIndexed(vk_activeCmdbuffer, (p->numverts - 2) * 3, 1, 0, 0, 0);
}

Referenced by R_DrawAlphaSurfaces(), and R_RenderBrushPoly().

DrawVkPoly()

void DrawVkPoly	(	vkpoly_t *	p,
		image_t *	texture,
		float *	color
	)

Definition at line 101 of file vk_rsurf.c.

{
    int     i;
    float   *v;
 
    typedef struct {
        float vertex[3];
        float texCoord[2];
    } polyvert;
 
    static polyvert verts[MAX_VERTS];
 
    v = p->verts[0];
    for (i = 0; i < p->numverts; i++, v += VERTEXSIZE)
    {
        verts[i].vertex[0] = v[0];
        verts[i].vertex[1] = v[1];
        verts[i].vertex[2] = v[2];
        verts[i].texCoord[0] = v[3];
        verts[i].texCoord[1] = v[4];
    }
 
    QVk_BindPipeline(&vk_drawPolyPipeline);
 
    VkBuffer vbo;
    VkDeviceSize vboOffset;
    uint32_t uboOffset;
    VkDescriptorSet uboDescriptorSet;
    uint8_t *vertData = QVk_GetVertexBuffer(sizeof(polyvert) * p->numverts, &vbo, &vboOffset);
    uint8_t *uboData  = QVk_GetUniformBuffer(sizeof(float) * 4, &uboOffset, &uboDescriptorSet);
    memcpy(vertData, verts, sizeof(polyvert) * p->numverts);
    memcpy(uboData,  color, sizeof(float) * 4);
 
    VkDescriptorSet descriptorSets[] = { texture->vk_texture.descriptorSet, uboDescriptorSet };
    vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_drawPolyPipeline.layout, 0, 2, descriptorSets, 1, &uboOffset);
    vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vbo, &vboOffset);
    vkCmdBindIndexBuffer(vk_activeCmdbuffer, QVk_GetTriangleFanIbo((p->numverts - 2) * 3), 0, VK_INDEX_TYPE_UINT16);
    vkCmdDrawIndexed(vk_activeCmdbuffer, (p->numverts - 2) * 3, 1, 0, 0, 0);
}

Referenced by R_DrawAlphaSurfaces(), and R_RenderBrushPoly().

LM_AllocBlock()

static qboolean LM_AllocBlock ( int  w, int  h, int *  x, int *  y  )

static

Definition at line 1097 of file vk_rsurf.c.

{
    int     i, j;
    int     best, best2;
 
    best = BLOCK_HEIGHT;
 
    for (i=0 ; i<BLOCK_WIDTH-w ; i++)
    {
        best2 = 0;
 
        for (j=0 ; j<w ; j++)
        {
            if (vk_lms.allocated[i+j] >= best)
                break;
            if (vk_lms.allocated[i+j] > best2)
                best2 = vk_lms.allocated[i+j];
        }
        if (j == w)
        {   // this is a valid spot
            *x = i;
            *y = best = best2;
        }
    }
 
    if (best + h > BLOCK_HEIGHT)
        return false;
 
    for (i=0 ; i<w ; i++)
        vk_lms.allocated[*x + i] = best + h;
 
    return true;
}

Referenced by Vk_CreateSurfaceLightmap().

LM_InitBlock()

static void LM_InitBlock ( void  )

static

Definition at line 1048 of file vk_rsurf.c.

{
    memset( vk_lms.allocated, 0, sizeof( vk_lms.allocated ) );
}

Referenced by Vk_CreateSurfaceLightmap().

LM_UploadBlock()

static void LM_UploadBlock ( qboolean  dynamic )

static

Definition at line 1053 of file vk_rsurf.c.

{
    int texture;
    int height = 0;
 
    if ( dynamic )
    {
        texture = 0;
    }
    else
    {
        texture = vk_lms.current_lightmap_texture;
    }
 
    if ( dynamic )
    {
        int i;
 
        for ( i = 0; i < BLOCK_WIDTH; i++ )
        {
            if ( vk_lms.allocated[i] > height )
                height = vk_lms.allocated[i];
        }
        QVk_UpdateTextureData(&vk_state.lightmap_textures[texture], vk_lms.lightmap_buffer, 0, 0, BLOCK_WIDTH, height);
    }
    else
    {
        if (vk_state.lightmap_textures[texture].image != VK_NULL_HANDLE)
            QVk_UpdateTextureData(&vk_state.lightmap_textures[texture], vk_lms.lightmap_buffer, 0, 0, BLOCK_WIDTH, BLOCK_HEIGHT);
        else
        {
            QVVKTEXTURE_CLEAR(vk_state.lightmap_textures[texture]);
            QVk_CreateTexture(&vk_state.lightmap_textures[texture], vk_lms.lightmap_buffer, BLOCK_WIDTH, BLOCK_HEIGHT, vk_current_lmap_sampler);
            QVk_DebugSetObjectName((uint64_t)vk_state.lightmap_textures[texture].image, VK_OBJECT_TYPE_IMAGE, va("Image: dynamic lightmap #%d", texture));
            QVk_DebugSetObjectName((uint64_t)vk_state.lightmap_textures[texture].imageView, VK_OBJECT_TYPE_IMAGE_VIEW, va("Image View: dynamic lightmap #%d", texture));
            QVk_DebugSetObjectName((uint64_t)vk_state.lightmap_textures[texture].descriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET, va("Descriptor Set: dynamic lightmap #%d", texture));
            QVk_DebugSetObjectName((uint64_t)vk_state.lightmap_textures[texture].allocInfo.deviceMemory, VK_OBJECT_TYPE_DEVICE_MEMORY, va("Memory: dynamic lightmap #%d", texture));
        }
        if ( ++vk_lms.current_lightmap_texture == MAX_LIGHTMAPS )
            ri.Sys_Error( ERR_DROP, "LM_UploadBlock() - MAX_LIGHTMAPS exceeded\n" );
    }
}

Referenced by Vk_CreateSurfaceLightmap(), and Vk_EndBuildingLightmaps().

R_BuildLightMap()

void R_BuildLightMap	(	msurface_t *	surf,
		byte *	dest,
		int	stride
	)

Definition at line 455 of file gl_light.c.

{
    int         smax, tmax;
    int         r, g, b, a, max;
    int         i, j, size;
    byte        *lightmap;
    float       scale[4];
    int         nummaps;
    float       *bl;
    lightstyle_t    *style;
    int monolightmap;
 
    if ( surf->texinfo->flags & (SURF_SKY|SURF_TRANS33|SURF_TRANS66|SURF_WARP) )
        ri.Sys_Error (ERR_DROP, "R_BuildLightMap called for non-lit surface");
 
    smax = (surf->extents[0]>>4)+1;
    tmax = (surf->extents[1]>>4)+1;
    size = smax*tmax;
    if (size > (sizeof(s_blocklights)>>4) )
        ri.Sys_Error (ERR_DROP, "Bad s_blocklights size");
 
// set to full bright if no light data
    if (!surf->samples)
    {
        int maps;
 
        for (i=0 ; i<size*3 ; i++)
            s_blocklights[i] = 255;
        for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
             maps++)
        {
            style = &r_newrefdef.lightstyles[surf->styles[maps]];
        }
        goto store;
    }
 
    // count the # of maps
    for ( nummaps = 0 ; nummaps < MAXLIGHTMAPS && surf->styles[nummaps] != 255 ;
         nummaps++)
        ;
 
    lightmap = surf->samples;
 
    // add all the lightmaps
    if ( nummaps == 1 )
    {
        int maps;
 
        for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
             maps++)
        {
            bl = s_blocklights;
 
            for (i=0 ; i<3 ; i++)
                scale[i] = gl_modulate->value*r_newrefdef.lightstyles[surf->styles[maps]].rgb[i];
 
            if ( scale[0] == 1.0F &&
                 scale[1] == 1.0F &&
                 scale[2] == 1.0F )
            {
                for (i=0 ; i<size ; i++, bl+=3)
                {
                    bl[0] = lightmap[i*3+0];
                    bl[1] = lightmap[i*3+1];
                    bl[2] = lightmap[i*3+2];
                }
            }
            else
            {
                for (i=0 ; i<size ; i++, bl+=3)
                {
                    bl[0] = lightmap[i*3+0] * scale[0];
                    bl[1] = lightmap[i*3+1] * scale[1];
                    bl[2] = lightmap[i*3+2] * scale[2];
                }
            }
            lightmap += size*3;     // skip to next lightmap
        }
    }
    else
    {
        int maps;
 
        memset( s_blocklights, 0, sizeof( s_blocklights[0] ) * size * 3 );
 
        for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
             maps++)
        {
            bl = s_blocklights;
 
            for (i=0 ; i<3 ; i++)
                scale[i] = gl_modulate->value*r_newrefdef.lightstyles[surf->styles[maps]].rgb[i];
 
            if ( scale[0] == 1.0F &&
                 scale[1] == 1.0F &&
                 scale[2] == 1.0F )
            {
                for (i=0 ; i<size ; i++, bl+=3 )
                {
                    bl[0] += lightmap[i*3+0];
                    bl[1] += lightmap[i*3+1];
                    bl[2] += lightmap[i*3+2];
                }
            }
            else
            {
                for (i=0 ; i<size ; i++, bl+=3)
                {
                    bl[0] += lightmap[i*3+0] * scale[0];
                    bl[1] += lightmap[i*3+1] * scale[1];
                    bl[2] += lightmap[i*3+2] * scale[2];
                }
            }
            lightmap += size*3;     // skip to next lightmap
        }
    }
 
// add all the dynamic lights
    if (surf->dlightframe == r_framecount)
        R_AddDynamicLights (surf);
 
// put into texture format
store:
    stride -= (smax<<2);
    bl = s_blocklights;
 
    monolightmap = gl_monolightmap->string[0];
 
    if ( monolightmap == '0' )
    {
        for (i=0 ; i<tmax ; i++, dest += stride)
        {
            for (j=0 ; j<smax ; j++)
            {
                
                r = Q_ftol( bl[0] );
                g = Q_ftol( bl[1] );
                b = Q_ftol( bl[2] );
 
                // catch negative lights
                if (r < 0)
                    r = 0;
                if (g < 0)
                    g = 0;
                if (b < 0)
                    b = 0;
 
                /*
                ** determine the brightest of the three color components
                */
                if (r > g)
                    max = r;
                else
                    max = g;
                if (b > max)
                    max = b;
 
                /*
                ** alpha is ONLY used for the mono lightmap case.  For this reason
                ** we set it to the brightest of the color components so that 
                ** things don't get too dim.
                */
                a = max;
 
                /*
                ** rescale all the color components if the intensity of the greatest
                ** channel exceeds 1.0
                */
                if (max > 255)
                {
                    float t = 255.0F / max;
 
                    r = r*t;
                    g = g*t;
                    b = b*t;
                    a = a*t;
                }
 
                dest[0] = r;
                dest[1] = g;
                dest[2] = b;
                dest[3] = a;
 
                bl += 3;
                dest += 4;
            }
        }
    }
    else
    {
        for (i=0 ; i<tmax ; i++, dest += stride)
        {
            for (j=0 ; j<smax ; j++)
            {
                
                r = Q_ftol( bl[0] );
                g = Q_ftol( bl[1] );
                b = Q_ftol( bl[2] );
 
                // catch negative lights
                if (r < 0)
                    r = 0;
                if (g < 0)
                    g = 0;
                if (b < 0)
                    b = 0;
 
                /*
                ** determine the brightest of the three color components
                */
                if (r > g)
                    max = r;
                else
                    max = g;
                if (b > max)
                    max = b;
 
                /*
                ** alpha is ONLY used for the mono lightmap case.  For this reason
                ** we set it to the brightest of the color components so that 
                ** things don't get too dim.
                */
                a = max;
 
                /*
                ** rescale all the color components if the intensity of the greatest
                ** channel exceeds 1.0
                */
                if (max > 255)
                {
                    float t = 255.0F / max;
 
                    r = r*t;
                    g = g*t;
                    b = b*t;
                    a = a*t;
                }
 
                /*
                ** So if we are doing alpha lightmaps we need to set the R, G, and B
                ** components to 0 and we need to set alpha to 1-alpha.
                */
                switch ( monolightmap )
                {
                case 'L':
                case 'I':
                    r = a;
                    g = b = 0;
                    break;
                case 'C':
                    // try faking colored lighting
                    a = 255 - ((r+g+b)/3);
                    r *= a/255.0;
                    g *= a/255.0;
                    b *= a/255.0;
                    break;
                case 'A':
                default:
                    r = g = b = 0;
                    a = 255 - a;
                    break;
                }
 
                dest[0] = r;
                dest[1] = g;
                dest[2] = b;
                dest[3] = a;
 
                bl += 3;
                dest += 4;
            }
        }
    }
}

Referenced by R_RenderBrushPoly(), Vk_CreateSurfaceLightmap(), and Vk_RenderLightmappedPoly().

R_DrawAlphaSurfaces()

void R_DrawAlphaSurfaces

(

void

)

Definition at line 362 of file vk_rsurf.c.

{
    msurface_t  *s;
    float       intens;
 
    // the textures are prescaled up for a better lighting range,
    // so scale it back down
    intens = vk_state.inverse_intensity;
    float color[4] = { intens, intens, intens, 1.f };
 
    for (s = r_alpha_surfaces; s; s = s->texturechain)
    {
        c_brush_polys++;
        if (s->texinfo->flags & SURF_TRANS33)
            color[3] = 0.33f;
        else if (s->texinfo->flags & SURF_TRANS66)
            color[3] = 0.66f;
 
        if (s->flags & SURF_DRAWTURB)
            EmitWaterPolys(s, s->texinfo->image, NULL, color);
        else if (s->texinfo->flags & SURF_FLOWING)          // PGM  9/16/98
            DrawVkFlowingPoly(s, s->texinfo->image, color); // PGM
        else
            DrawVkPoly(s->polys, s->texinfo->image, color);
    }
 
    r_alpha_surfaces = NULL;
}

Referenced by R_RenderFrame(), and R_RenderView().

R_DrawBrushModel()

void R_DrawBrushModel

(

entity_t *

e

)

Definition at line 738 of file vk_rsurf.c.

{
    vec3_t      mins, maxs;
    int         i;
    qboolean    rotated;
 
    if (currentmodel->nummodelsurfaces == 0)
        return;
 
    currententity = e;
 
    if (e->angles[0] || e->angles[1] || e->angles[2])
    {
        rotated = true;
        for (i = 0; i<3; i++)
        {
            mins[i] = e->origin[i] - currentmodel->radius;
            maxs[i] = e->origin[i] + currentmodel->radius;
        }
    }
    else
    {
        rotated = false;
        VectorAdd(e->origin, currentmodel->mins, mins);
        VectorAdd(e->origin, currentmodel->maxs, maxs);
    }
 
    if (R_CullBox(mins, maxs))
        return;
 
    memset(vk_lms.lightmap_surfaces, 0, sizeof(vk_lms.lightmap_surfaces));
 
    VectorSubtract(r_newrefdef.vieworg, e->origin, modelorg);
    if (rotated)
    {
        vec3_t  temp;
        vec3_t  forward, right, up;
 
        VectorCopy(modelorg, temp);
        AngleVectors(e->angles, forward, right, up);
        modelorg[0] = DotProduct(temp, forward);
        modelorg[1] = -DotProduct(temp, right);
        modelorg[2] = DotProduct(temp, up);
    }
 
    e->angles[0] = -e->angles[0];   // stupid quake bug
    e->angles[2] = -e->angles[2];   // stupid quake bug
    float model[16];
    Mat_Identity(model);
    R_RotateForEntity(e, model);
    e->angles[0] = -e->angles[0];   // stupid quake bug
    e->angles[2] = -e->angles[2];   // stupid quake bug
 
    R_DrawInlineBModel(model);
}

Referenced by R_DrawEntitiesOnList().

R_DrawInlineBModel()

void R_DrawInlineBModel

(

float *

modelMatrix

)

Definition at line 676 of file vk_rsurf.c.

{
    int         i, k;
    cplane_t    *pplane;
    float       dot;
    msurface_t  *psurf;
    dlight_t    *lt;
    float       alpha = 1.f;
 
    // calculate dynamic lighting for bmodel
    if (!vk_flashblend->value)
    {
        lt = r_newrefdef.dlights;
        for (k = 0; k<r_newrefdef.num_dlights; k++, lt++)
        {
            R_MarkLights(lt, 1 << k, currentmodel->nodes + currentmodel->firstnode);
        }
    }
 
    psurf = &currentmodel->surfaces[currentmodel->firstmodelsurface];
 
    if (currententity->flags & RF_TRANSLUCENT)
    {
        alpha = .25f;
    }
 
    //
    // draw texture
    //
    for (i = 0; i<currentmodel->nummodelsurfaces; i++, psurf++)
    {
        // find which side of the node we are on
        pplane = psurf->plane;
 
        dot = DotProduct(modelorg, pplane->normal) - pplane->dist;
 
        // draw the polygon
        if (((psurf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
            (!(psurf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON)))
        {
            if (psurf->texinfo->flags & (SURF_TRANS33 | SURF_TRANS66))
            {   // add to the translucent chain
                psurf->texturechain = r_alpha_surfaces;
                r_alpha_surfaces = psurf;
            }
            else if (!(psurf->flags & SURF_DRAWTURB) && !vk_showtris->value)
            {
                Vk_RenderLightmappedPoly(psurf, modelMatrix, alpha);
            }
            else
            {
                R_RenderBrushPoly(psurf, modelMatrix, alpha);
            }
        }
    }
}

Referenced by R_DrawBrushModel().

R_DrawTriangleOutlines()

void R_DrawTriangleOutlines

(

void

)

Definition at line 201 of file vk_rsurf.c.

{
    int         i, j, k;
    vkpoly_t    *p;
 
    if (!vk_showtris->value)
        return;
 
    VkBuffer vbo;
    VkDeviceSize vboOffset;
    float color[3] = { 1.f, 1.f, 1.f };
    struct {
        vec3_t v;
        float color[3];
    } triVert[4];
 
    QVk_BindPipeline(&vk_showTrisPipeline);
    uint32_t uboOffset;
    VkDescriptorSet uboDescriptorSet;
    uint8_t *uboData = QVk_GetUniformBuffer(sizeof(r_viewproj_matrix), &uboOffset, &uboDescriptorSet);
    memcpy(uboData, r_viewproj_matrix, sizeof(r_viewproj_matrix));
    vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_showTrisPipeline.layout, 0, 1, &uboDescriptorSet, 1, &uboOffset);
 
    for (i = 0; i < MAX_LIGHTMAPS; i++)
    {
        msurface_t *surf;
 
        for (surf = vk_lms.lightmap_surfaces[i]; surf != 0; surf = surf->lightmapchain)
        {
            p = surf->polys;
            for (; p; p = p->chain)
            {
                for (j = 2, k = 0; j < p->numverts; j++, k++)
                {
                    triVert[0].v[0] = p->verts[0][0];
                    triVert[0].v[1] = p->verts[0][1];
                    triVert[0].v[2] = p->verts[0][2];
                    memcpy(triVert[0].color, color, sizeof(color));
 
                    triVert[1].v[0] = p->verts[j - 1][0];
                    triVert[1].v[1] = p->verts[j - 1][1];
                    triVert[1].v[2] = p->verts[j - 1][2];
                    memcpy(triVert[1].color, color, sizeof(color));
 
                    triVert[2].v[0] = p->verts[j][0];
                    triVert[2].v[1] = p->verts[j][1];
                    triVert[2].v[2] = p->verts[j][2];
                    memcpy(triVert[2].color, color, sizeof(color));
 
                    triVert[3].v[0] = p->verts[0][0];
                    triVert[3].v[1] = p->verts[0][1];
                    triVert[3].v[2] = p->verts[0][2];
                    memcpy(triVert[3].color, color, sizeof(color));
 
                    uint8_t *vertData = QVk_GetVertexBuffer(sizeof(triVert), &vbo, &vboOffset);
                    memcpy(vertData, triVert, sizeof(triVert));
 
                    vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vbo, &vboOffset);
                    vkCmdDraw(vk_activeCmdbuffer, 4, 1, 0, 0);
                }
            }
        }
    }
}

Referenced by R_DrawWorld().

R_DrawWorld()

void R_DrawWorld

(

void

)

Definition at line 932 of file vk_rsurf.c.

{
    entity_t    ent;
 
    if (!r_drawworld->value)
        return;
 
    if ( r_newrefdef.rdflags & RDF_NOWORLDMODEL )
        return;
 
    currentmodel = r_worldmodel;
 
    VectorCopy (r_newrefdef.vieworg, modelorg);
 
    // auto cycle the world frame for texture animation
    memset (&ent, 0, sizeof(ent));
    ent.frame = (int)(r_newrefdef.time*2);
    currententity = &ent;
 
    memset (vk_lms.lightmap_surfaces, 0, sizeof(vk_lms.lightmap_surfaces));
    R_ClearSkyBox ();
 
    R_RecursiveWorldNode (r_worldmodel->nodes);
 
    /*
    ** theoretically nothing should happen in the next two functions
    ** if multitexture is enabled - in practice, this code renders non-transparent liquids!
    */
    DrawTextureChains ();
 
    R_DrawSkyBox ();
 
    R_DrawTriangleOutlines ();
}

Referenced by R_RenderView().

R_MarkLeaves()

void R_MarkLeaves

(

void

)

Definition at line 976 of file vk_rsurf.c.

{
    byte    *vis;
    byte    fatvis[MAX_MAP_LEAFS/8];
    mnode_t *node;
    int     i, c;
    mleaf_t *leaf;
    int     cluster;
 
    if (r_oldviewcluster == r_viewcluster && r_oldviewcluster2 == r_viewcluster2 && !r_novis->value && r_viewcluster != -1)
        return;
 
    // development aid to let you run around and see exactly where
    // the pvs ends
    if (vk_lockpvs->value)
        return;
 
    r_visframecount++;
    r_oldviewcluster = r_viewcluster;
    r_oldviewcluster2 = r_viewcluster2;
 
    if (r_novis->value || r_viewcluster == -1 || !r_worldmodel->vis)
    {
        // mark everything
        for (i=0 ; i<r_worldmodel->numleafs ; i++)
            r_worldmodel->leafs[i].visframe = r_visframecount;
        for (i=0 ; i<r_worldmodel->numnodes ; i++)
            r_worldmodel->nodes[i].visframe = r_visframecount;
        return;
    }
 
    vis = Mod_ClusterPVS (r_viewcluster, r_worldmodel);
    // may have to combine two clusters because of solid water boundaries
    if (r_viewcluster2 != r_viewcluster)
    {
        memcpy (fatvis, vis, (r_worldmodel->numleafs+7)/8);
        vis = Mod_ClusterPVS (r_viewcluster2, r_worldmodel);
        c = (r_worldmodel->numleafs+31)/32;
        for (i=0 ; i<c ; i++)
            ((int *)fatvis)[i] |= ((int *)vis)[i];
        vis = fatvis;
    }
    
    for (i=0,leaf=r_worldmodel->leafs ; i<r_worldmodel->numleafs ; i++, leaf++)
    {
        cluster = leaf->cluster;
        if (cluster == -1)
            continue;
        if (vis[cluster>>3] & (1<<(cluster&7)))
        {
            node = (mnode_t *)leaf;
            do
            {
                if (node->visframe == r_visframecount)
                    break;
                node->visframe = r_visframecount;
                node = node->parent;
            } while (node);
        }
    }
}

R_RecursiveWorldNode()

void R_RecursiveWorldNode

(

mnode_t *

node

)

Definition at line 807 of file vk_rsurf.c.

{
    int         c, side, sidebit;
    cplane_t    *plane;
    msurface_t  *surf, **mark;
    mleaf_t     *pleaf;
    float       dot;
    image_t     *image;
 
    if (node->contents == CONTENTS_SOLID)
        return;     // solid
 
    if (node->visframe != r_visframecount)
        return;
    if (R_CullBox (node->minmaxs, node->minmaxs+3))
        return;
    
// if a leaf node, draw stuff
    if (node->contents != -1)
    {
        pleaf = (mleaf_t *)node;
 
        // check for door connected areas
        if (r_newrefdef.areabits)
        {
            if (! (r_newrefdef.areabits[pleaf->area>>3] & (1<<(pleaf->area&7)) ) )
                return;     // not visible
        }
 
        mark = pleaf->firstmarksurface;
        c = pleaf->nummarksurfaces;
 
        if (c)
        {
            do
            {
                (*mark)->visframe = r_framecount;
                mark++;
            } while (--c);
        }
 
        return;
    }
 
// node is just a decision point, so go down the apropriate sides
 
// find which side of the node we are on
    plane = node->plane;
 
    switch (plane->type)
    {
    case PLANE_X:
        dot = modelorg[0] - plane->dist;
        break;
    case PLANE_Y:
        dot = modelorg[1] - plane->dist;
        break;
    case PLANE_Z:
        dot = modelorg[2] - plane->dist;
        break;
    default:
        dot = DotProduct (modelorg, plane->normal) - plane->dist;
        break;
    }
 
    if (dot >= 0)
    {
        side = 0;
        sidebit = 0;
    }
    else
    {
        side = 1;
        sidebit = SURF_PLANEBACK;
    }
 
// recurse down the children, front side first
    R_RecursiveWorldNode (node->children[side]);
 
    // draw stuff
    for ( c = node->numsurfaces, surf = r_worldmodel->surfaces + node->firstsurface; c ; c--, surf++)
    {
        if (surf->visframe != r_framecount)
            continue;
 
        if ( (surf->flags & SURF_PLANEBACK) != sidebit )
            continue;       // wrong side
 
        if (surf->texinfo->flags & SURF_SKY)
        {   // just adds to visible sky bounds
            R_AddSkySurface (surf);
        }
        else if (surf->texinfo->flags & (SURF_TRANS33|SURF_TRANS66))
        {   // add to the translucent chain
            surf->texturechain = r_alpha_surfaces;
            r_alpha_surfaces = surf;
        }
        else
        {
            if (!(surf->flags & SURF_DRAWTURB) && !vk_showtris->value)
            {
                Vk_RenderLightmappedPoly(surf, NULL, 1.f);
            }
            else
            {
                // the polygon is visible, so add it to the texture
                // sorted chain
                // FIXME: this is a hack for animation
                image = R_TextureAnimation(surf->texinfo);
                surf->texturechain = image->texturechain;
                image->texturechain = surf;
            }
        }
    }
 
    // recurse down the back side
    R_RecursiveWorldNode (node->children[!side]);
}

Referenced by R_DrawWorld().

R_RenderBrushPoly()

void R_RenderBrushPoly	(	msurface_t *	fa,
		float *	modelMatrix,
		float	alpha
	)

Definition at line 271 of file vk_rsurf.c.

{
    int         maps;
    image_t     *image;
    qboolean is_dynamic = false;
    float       color[4] = { 1.f, 1.f, 1.f, alpha };
    c_brush_polys++;
 
    image = R_TextureAnimation(fa->texinfo);
 
    if (fa->flags & SURF_DRAWTURB)
    {
        color[0] = color[1] = color[2] = vk_state.inverse_intensity;
        color[3] = 1.f;
        // warp texture, no lightmaps
        EmitWaterPolys(fa, image, modelMatrix, color);
        return;
    }
 
    //======
    //PGM
    if (fa->texinfo->flags & SURF_FLOWING)
        DrawVkFlowingPoly(fa, image, color);
    else
        DrawVkPoly(fa->polys, image, color);
    //PGM
    //======
 
    /*
    ** check for lightmap modification
    */
    for (maps = 0; maps < MAXLIGHTMAPS && fa->styles[maps] != 255; maps++)
    {
        if (r_newrefdef.lightstyles[fa->styles[maps]].white != fa->cached_light[maps])
            goto dynamic;
    }
 
    // dynamic this frame or dynamic previously
    if (fa->dlightframe == r_framecount)
    {
    dynamic:
        if (vk_dynamic->value)
        {
            if (!(fa->texinfo->flags & (SURF_SKY | SURF_TRANS33 | SURF_TRANS66 | SURF_WARP)))
            {
                is_dynamic = true;
            }
        }
    }
 
    if (is_dynamic)
    {
        if ((fa->styles[maps] >= 32 || fa->styles[maps] == 0) && (fa->dlightframe != r_framecount))
        {
            unsigned    temp[34 * 34];
            int         smax, tmax;
 
            smax = (fa->extents[0] >> 4) + 1;
            tmax = (fa->extents[1] >> 4) + 1;
 
            R_BuildLightMap(fa, (void *)temp, smax * 4);
            R_SetCacheState(fa);
 
            QVk_UpdateTextureData(&vk_state.lightmap_textures[fa->lightmaptexturenum], (unsigned char*)temp, fa->light_s, fa->light_t, smax, tmax);
            
            fa->lightmapchain = vk_lms.lightmap_surfaces[fa->lightmaptexturenum];
            vk_lms.lightmap_surfaces[fa->lightmaptexturenum] = fa;
        }
        else
        {
            fa->lightmapchain = vk_lms.lightmap_surfaces[0];
            vk_lms.lightmap_surfaces[0] = fa;
        }
    }
    else
    {
        fa->lightmapchain = vk_lms.lightmap_surfaces[fa->lightmaptexturenum];
        vk_lms.lightmap_surfaces[fa->lightmaptexturenum] = fa;
    }
}

Referenced by DrawTextureChains(), and R_DrawInlineBModel().

R_SetCacheState()

void R_SetCacheState

(

msurface_t *

surf

)

Definition at line 437 of file gl_light.c.

{
    int maps;
 
    for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
         maps++)
    {
        surf->cached_light[maps] = r_newrefdef.lightstyles[surf->styles[maps]].white;
    }
}

Referenced by R_RenderBrushPoly(), Vk_CreateSurfaceLightmap(), and Vk_RenderLightmappedPoly().

R_TextureAnimation()

image_t* R_TextureAnimation

(

mtexinfo_t *

tex

)

Definition at line 79 of file vk_rsurf.c.

{
    int     c;
 
    if (!tex->next)
        return tex->image;
 
    c = currententity->frame % tex->numframes;
    while (c)
    {
        tex = tex->next;
        c--;
    }
 
    return tex->image;
}

Referenced by R_RecursiveWorldNode(), R_RenderBrushPoly(), and Vk_RenderLightmappedPoly().

Vk_BeginBuildingLightmaps()

void Vk_BeginBuildingLightmaps

(

model_t *

m

)

Definition at line 1249 of file vk_rsurf.c.

{
    static lightstyle_t lightstyles[MAX_LIGHTSTYLES];
    int             i;
    unsigned        dummy[BLOCK_WIDTH * BLOCK_HEIGHT];
 
    memset(vk_lms.allocated, 0, sizeof(vk_lms.allocated));
 
    r_framecount = 1;       // no dlightcache
 
    /*
    ** setup the base lightstyles so the lightmaps won't have to be regenerated
    ** the first time they're seen
    */
    for (i = 0; i < MAX_LIGHTSTYLES; i++)
    {
        lightstyles[i].rgb[0] = 1;
        lightstyles[i].rgb[1] = 1;
        lightstyles[i].rgb[2] = 1;
        lightstyles[i].white = 3;
    }
    r_newrefdef.lightstyles = lightstyles;
 
    vk_lms.current_lightmap_texture = 0;
 
    /*
    ** initialize the dynamic lightmap textures
    */
    if (vk_state.lightmap_textures[DYNLIGHTMAP_OFFSET].image == VK_NULL_HANDLE)
    {
        for (i = DYNLIGHTMAP_OFFSET; i < MAX_LIGHTMAPS*2; i++)
        {
            QVVKTEXTURE_CLEAR(vk_state.lightmap_textures[i]);
            QVk_CreateTexture(&vk_state.lightmap_textures[i], (unsigned char*)dummy, BLOCK_WIDTH, BLOCK_HEIGHT, vk_current_lmap_sampler);
            QVk_DebugSetObjectName((uint64_t)vk_state.lightmap_textures[i].image, VK_OBJECT_TYPE_IMAGE, va("Image: dynamic lightmap #%d", i));
            QVk_DebugSetObjectName((uint64_t)vk_state.lightmap_textures[i].imageView, VK_OBJECT_TYPE_IMAGE_VIEW, va("Image View: dynamic lightmap #%d", i));
            QVk_DebugSetObjectName((uint64_t)vk_state.lightmap_textures[i].descriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET, va("Descriptor Set: dynamic lightmap #%d", i));
            QVk_DebugSetObjectName((uint64_t)vk_state.lightmap_textures[i].allocInfo.deviceMemory, VK_OBJECT_TYPE_DEVICE_MEMORY, va("Memory: dynamic lightmap #%d", i));
        }
    }
}

Referenced by Mod_LoadFaces().

Vk_BuildPolygonFromSurface()

void Vk_BuildPolygonFromSurface

(

msurface_t *

fa

)

Definition at line 1136 of file vk_rsurf.c.

{
    int         i, lindex, lnumverts;
    medge_t     *pedges, *r_pedge;
    float       *vec;
    float       s, t;
    vkpoly_t    *poly;
    vec3_t      total;
 
// reconstruct the polygon
    pedges = currentmodel->edges;
    lnumverts = fa->numedges;
 
    VectorClear (total);
    //
    // draw texture
    //
    poly = Hunk_Alloc (sizeof(vkpoly_t) + (lnumverts-4) * VERTEXSIZE*sizeof(float));
    poly->next = fa->polys;
    poly->flags = fa->flags;
    fa->polys = poly;
    poly->numverts = lnumverts;
 
    for (i=0 ; i<lnumverts ; i++)
    {
        lindex = currentmodel->surfedges[fa->firstedge + i];
 
        if (lindex > 0)
        {
            r_pedge = &pedges[lindex];
            vec = currentmodel->vertexes[r_pedge->v[0]].position;
        }
        else
        {
            r_pedge = &pedges[-lindex];
            vec = currentmodel->vertexes[r_pedge->v[1]].position;
        }
        s = DotProduct (vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
        s /= fa->texinfo->image->width;
 
        t = DotProduct (vec, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3];
        t /= fa->texinfo->image->height;
 
        VectorAdd (total, vec, total);
        VectorCopy (vec, poly->verts[i]);
        poly->verts[i][3] = s;
        poly->verts[i][4] = t;
 
        //
        // lightmap texture coordinates
        //
        s = DotProduct (vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
        s -= fa->texturemins[0];
        s += fa->light_s*16;
        s += 8;
        s /= BLOCK_WIDTH*16; //fa->texinfo->texture->width;
 
        t = DotProduct (vec, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3];
        t -= fa->texturemins[1];
        t += fa->light_t*16;
        t += 8;
        t /= BLOCK_HEIGHT*16; //fa->texinfo->texture->height;
 
        poly->verts[i][5] = s;
        poly->verts[i][6] = t;
    }
 
    poly->numverts = lnumverts;
 
}

Referenced by Mod_LoadFaces().

Vk_CreateSurfaceLightmap()

void Vk_CreateSurfaceLightmap

(

msurface_t *

surf

)

Definition at line 1212 of file vk_rsurf.c.

{
    int     smax, tmax;
    byte    *base;
 
    if (surf->flags & (SURF_DRAWSKY|SURF_DRAWTURB))
        return;
 
    smax = (surf->extents[0]>>4)+1;
    tmax = (surf->extents[1]>>4)+1;
 
    if ( !LM_AllocBlock( smax, tmax, &surf->light_s, &surf->light_t ) )
    {
        LM_UploadBlock( false );
        LM_InitBlock();
        if ( !LM_AllocBlock( smax, tmax, &surf->light_s, &surf->light_t ) )
        {
            ri.Sys_Error( ERR_FATAL, "Consecutive calls to LM_AllocBlock(%d,%d) failed\n", smax, tmax );
        }
    }
 
    surf->lightmaptexturenum = vk_lms.current_lightmap_texture;
 
    base = vk_lms.lightmap_buffer;
    base += (surf->light_t * BLOCK_WIDTH + surf->light_s) * LIGHTMAP_BYTES;
 
    R_SetCacheState( surf );
    R_BuildLightMap (surf, base, BLOCK_WIDTH*LIGHTMAP_BYTES);
}

Referenced by Mod_LoadFaces().

Vk_EndBuildingLightmaps()

void Vk_EndBuildingLightmaps

(

void

)

Definition at line 1296 of file vk_rsurf.c.

{
    LM_UploadBlock( false );
}

Referenced by Mod_LoadFaces().

Vk_RenderLightmappedPoly()

static void Vk_RenderLightmappedPoly ( msurface_t *  surf, float *  modelMatrix, float  alpha  )

static

Definition at line 438 of file vk_rsurf.c.

{
    int     i, nv = surf->polys->numverts;
    int     map;
    float   *v;
    image_t *image = R_TextureAnimation(surf->texinfo);
    qboolean is_dynamic = false;
    unsigned lmtex = surf->lightmaptexturenum;
    vkpoly_t *p;
 
    typedef struct {
        float vertex[3];
        float texCoord[2];
        float texCoordLmap[2];
    } lmappolyvert;
 
    static lmappolyvert verts[MAX_VERTS];
 
    struct {
        float model[16];
        float viewLightmaps;
    } lmapPolyUbo;
 
    lmapPolyUbo.viewLightmaps = vk_lightmap->value ? 1.f : 0.f;
 
    if (modelMatrix)
    {
        memcpy(lmapPolyUbo.model, modelMatrix, sizeof(float) * 16);
    }
    else
    {
        Mat_Identity(lmapPolyUbo.model);
    }
 
    QVk_BindPipeline(&vk_drawPolyLmapPipeline);
 
    uint32_t uboOffset;
    VkDescriptorSet uboDescriptorSet;
    uint8_t *uboData = QVk_GetUniformBuffer(sizeof(lmapPolyUbo), &uboOffset, &uboDescriptorSet);
    memcpy(uboData, &lmapPolyUbo, sizeof(lmapPolyUbo));
 
    for (map = 0; map < MAXLIGHTMAPS && surf->styles[map] != 255; map++)
    {
        if (r_newrefdef.lightstyles[surf->styles[map]].white != surf->cached_light[map])
            goto dynamic;
    }
 
    // dynamic this frame or dynamic previously
    if (surf->dlightframe == r_framecount)
    {
    dynamic:
        if (vk_dynamic->value)
        {
            if (!(surf->texinfo->flags & (SURF_SKY | SURF_TRANS33 | SURF_TRANS66 | SURF_WARP)))
            {
                is_dynamic = true;
            }
        }
    }
 
    if (is_dynamic)
    {
        unsigned    temp[128 * 128];
        int         smax, tmax;
 
        if ((surf->styles[map] >= 32 || surf->styles[map] == 0) && (surf->dlightframe != r_framecount))
        {
            smax = (surf->extents[0] >> 4) + 1;
            tmax = (surf->extents[1] >> 4) + 1;
 
            R_BuildLightMap(surf, (void *)temp, smax * 4);
            R_SetCacheState(surf);
 
            lmtex = surf->lightmaptexturenum;
            QVk_UpdateTextureData(&vk_state.lightmap_textures[surf->lightmaptexturenum], (unsigned char *)temp, surf->light_s, surf->light_t, smax, tmax);
        }
        else
        {
            smax = (surf->extents[0] >> 4) + 1;
            tmax = (surf->extents[1] >> 4) + 1;
 
            R_BuildLightMap(surf, (void *)temp, smax * 4);
 
            lmtex = surf->lightmaptexturenum + DYNLIGHTMAP_OFFSET;
            QVk_UpdateTextureData(&vk_state.lightmap_textures[lmtex], (unsigned char *)temp, surf->light_s, surf->light_t, smax, tmax);
        }
 
        c_brush_polys++;
 
        //==========
        //PGM
        if (surf->texinfo->flags & SURF_FLOWING)
        {
            float scroll;
 
            scroll = -64 * ((r_newrefdef.time / 40.0) - (int)(r_newrefdef.time / 40.0));
            if (scroll == 0.0)
                scroll = -64.0;
 
            VkBuffer vbo;
            VkDeviceSize vboOffset;
            VkDescriptorSet descriptorSets[] = { image->vk_texture.descriptorSet, uboDescriptorSet, vk_state.lightmap_textures[lmtex].descriptorSet };
            vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_drawPolyLmapPipeline.layout, 0, 3, descriptorSets, 1, &uboOffset);
 
            for (p = surf->polys; p; p = p->chain)
            {
                v = p->verts[0];
                for (i = 0; i < nv; i++, v += VERTEXSIZE)
                {
                    verts[i].vertex[0] = v[0];
                    verts[i].vertex[1] = v[1];
                    verts[i].vertex[2] = v[2];
                    verts[i].texCoord[0] = v[3] + scroll;
                    verts[i].texCoord[1] = v[4];
                    verts[i].texCoordLmap[0] = v[5];
                    verts[i].texCoordLmap[1] = v[6];
                }
 
                uint8_t *vertData = QVk_GetVertexBuffer(sizeof(lmappolyvert) * nv, &vbo, &vboOffset);
                memcpy(vertData, verts, sizeof(lmappolyvert) * nv);
 
                vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vbo, &vboOffset);
                vkCmdBindIndexBuffer(vk_activeCmdbuffer, QVk_GetTriangleFanIbo((nv - 2) * 3), 0, VK_INDEX_TYPE_UINT16);
                vkCmdDrawIndexed(vk_activeCmdbuffer, (nv - 2) * 3, 1, 0, 0, 0);
            }
        }
        else
        {
            VkBuffer vbo;
            VkDeviceSize vboOffset;
            VkDescriptorSet descriptorSets[] = { image->vk_texture.descriptorSet, uboDescriptorSet, vk_state.lightmap_textures[lmtex].descriptorSet };
            vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_drawPolyLmapPipeline.layout, 0, 3, descriptorSets, 1, &uboOffset);
 
            for (p = surf->polys; p; p = p->chain)
            {
                v = p->verts[0];
                for (i = 0; i < nv; i++, v += VERTEXSIZE)
                {
                    verts[i].vertex[0] = v[0];
                    verts[i].vertex[1] = v[1];
                    verts[i].vertex[2] = v[2];
                    verts[i].texCoord[0] = v[3];
                    verts[i].texCoord[1] = v[4];
                    verts[i].texCoordLmap[0] = v[5];
                    verts[i].texCoordLmap[1] = v[6];
                }
 
                uint8_t *vertData = QVk_GetVertexBuffer(sizeof(lmappolyvert) * nv, &vbo, &vboOffset);
                memcpy(vertData, verts, sizeof(lmappolyvert) * nv);
 
                vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vbo, &vboOffset);
                vkCmdBindIndexBuffer(vk_activeCmdbuffer, QVk_GetTriangleFanIbo((nv - 2) * 3), 0, VK_INDEX_TYPE_UINT16);
                vkCmdDrawIndexed(vk_activeCmdbuffer, (nv - 2) * 3, 1, 0, 0, 0);
            }
        }
        //PGM
        //==========
    }
    else
    {
        c_brush_polys++;
 
        //==========
        //PGM
        if (surf->texinfo->flags & SURF_FLOWING)
        {
            float scroll;
 
            scroll = -64 * ((r_newrefdef.time / 40.0) - (int)(r_newrefdef.time / 40.0));
            if (scroll == 0.0)
                scroll = -64.0;
 
            for (p = surf->polys; p; p = p->chain)
            {
                v = p->verts[0];
                for (i = 0; i < nv; i++, v += VERTEXSIZE)
                {
                    verts[i].vertex[0] = v[0];
                    verts[i].vertex[1] = v[1];
                    verts[i].vertex[2] = v[2];
                    verts[i].texCoord[0] = v[3] + scroll;
                    verts[i].texCoord[1] = v[4];
                    verts[i].texCoordLmap[0] = v[5];
                    verts[i].texCoordLmap[1] = v[6];
                }
                VkBuffer vbo;
                VkDeviceSize vboOffset;
                uint8_t *vertData = QVk_GetVertexBuffer(sizeof(lmappolyvert) * nv, &vbo, &vboOffset);
                memcpy(vertData, verts, sizeof(lmappolyvert) * nv);
 
                VkDescriptorSet descriptorSets[] = { image->vk_texture.descriptorSet, uboDescriptorSet, vk_state.lightmap_textures[lmtex].descriptorSet };
                vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_drawPolyLmapPipeline.layout, 0, 3, descriptorSets, 1, &uboOffset);
                vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vbo, &vboOffset);
                vkCmdBindIndexBuffer(vk_activeCmdbuffer, QVk_GetTriangleFanIbo((nv - 2) * 3), 0, VK_INDEX_TYPE_UINT16);
                vkCmdDrawIndexed(vk_activeCmdbuffer, (nv - 2) * 3, 1, 0, 0, 0);
            }
        }
        else
        {
            //PGM
            //==========
            for (p = surf->polys; p; p = p->chain)
            {
                v = p->verts[0];
                for (i = 0; i < nv; i++, v += VERTEXSIZE)
                {
                    verts[i].vertex[0] = v[0];
                    verts[i].vertex[1] = v[1];
                    verts[i].vertex[2] = v[2];
                    verts[i].texCoord[0] = v[3];
                    verts[i].texCoord[1] = v[4];
                    verts[i].texCoordLmap[0] = v[5];
                    verts[i].texCoordLmap[1] = v[6];
                }
                VkBuffer vbo;
                VkDeviceSize vboOffset;
                uint8_t *vertData = QVk_GetVertexBuffer(sizeof(lmappolyvert) * nv, &vbo, &vboOffset);
                memcpy(vertData, verts, sizeof(lmappolyvert) * nv);
 
                VkDescriptorSet descriptorSets[] = { image->vk_texture.descriptorSet, uboDescriptorSet, vk_state.lightmap_textures[lmtex].descriptorSet };
                vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_drawPolyLmapPipeline.layout, 0, 3, descriptorSets, 1, &uboOffset);
                vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vbo, &vboOffset);
                vkCmdBindIndexBuffer(vk_activeCmdbuffer, QVk_GetTriangleFanIbo((nv - 2) * 3), 0, VK_INDEX_TYPE_UINT16);
                vkCmdDrawIndexed(vk_activeCmdbuffer, (nv - 2) * 3, 1, 0, 0, 0);
            }
            //==========
            //PGM
        }
        //PGM
        //==========
    }
}

Referenced by R_DrawInlineBModel(), and R_RecursiveWorldNode().

Variable Documentation

c_visible_lightmaps

int c_visible_lightmaps

Definition at line 38 of file vk_rsurf.c.

Referenced by R_RenderView().

c_visible_textures

int c_visible_textures

Definition at line 39 of file vk_rsurf.c.

Referenced by DrawTextureChains(), and R_RenderView().

modelorg

vec3_t modelorg

static

Definition at line 26 of file vk_rsurf.c.

Referenced by R_DrawBrushModel(), R_DrawInlineBModel(), R_DrawWorld(), and R_RecursiveWorldNode().

r_alpha_surfaces

msurface_t* r_alpha_surfaces

Definition at line 28 of file vk_rsurf.c.

Referenced by R_DrawAlphaSurfaces(), R_DrawInlineBModel(), R_RecursiveWorldNode(), R_RenderBmodelFace(), and R_RenderFace().

vk_lms

vklightmapstate_t vk_lms

static

Definition at line 54 of file vk_rsurf.c.

Referenced by LM_AllocBlock(), LM_InitBlock(), LM_UploadBlock(), R_DrawBrushModel(), R_DrawTriangleOutlines(), R_DrawWorld(), R_RenderBrushPoly(), Vk_BeginBuildingLightmaps(), and Vk_CreateSurfaceLightmap().