cpmadevs/cnq3
0
0
Fork 0
mirror of https://bitbucket.org/CPMADevs/cnq3 synced 2024-12-02 17:01:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
cnq3/code/renderer/tr_cmds.cpp

297 lines
7.7 KiB
C++
Raw Normal View History

import from cnq3 1.47
2016-12-18 04:43:04 +00:00
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code 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 2 of the License,
or (at your option) any later version.
Quake III Arena source code 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.
You should have received a copy of the GNU General Public License
along with Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
#include "tr_local.h"
added OpenGL 3.2 and Direct3D 11 renderer back-ends
2019-09-25 03:25:59 +00:00
void R_IssueRenderCommands()
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
{
deleted 2-threads rendering support (SMP)
2017-11-03 18:34:32 +00:00
renderCommandList_t* cmdList = &backEndData->commands;
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
// add an end-of-list command
*(int *)(cmdList->cmds + cmdList->used) = RC_END_OF_LIST;
// clear it out, in case this is a sync and not a buffer flip
cmdList->used = 0;
RB_ExecuteRenderCommands( cmdList->cmds );
}
added OpenGL 3.2 and Direct3D 11 renderer back-ends
2019-09-25 03:25:59 +00:00
void* R_FindRenderCommand( renderCommand_t type )
{
renderCommandList_t* cmdList = &backEndData->commands;
void* data = cmdList->cmds;
void* end = cmdList->cmds + cmdList->used;
while ( 1 ) {
data = PADP(data, sizeof(void *));
if( *(int *)data == type )
return data;
if ( data >= end )
return NULL;
switch ( *(const int *)data ) {
case RC_SET_COLOR:
data = (char*)data + sizeof(setColorCommand_t);
break;
case RC_STRETCH_PIC:
data = (char*)data + sizeof(stretchPicCommand_t);
break;
case RC_TRIANGLE:
data = (char*)data + sizeof(triangleCommand_t);
break;
case RC_DRAW_SURFS:
data = (char*)data + sizeof(drawSurfsCommand_t);
break;
case RC_BEGIN_FRAME:
data = (char*)data + sizeof(beginFrameCommand_t);
break;
case RC_SWAP_BUFFERS:
data = (char*)data + sizeof(swapBuffersCommand_t);
break;
case RC_SCREENSHOT:
data = (char*)data + sizeof(screenshotCommand_t);
break;
case RC_VIDEOFRAME:
data = (char*)data + sizeof(videoFrameCommand_t);
break;
case RC_END_OF_LIST:
default:
return NULL;
}
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
}
}
added OpenGL 3.2 and Direct3D 11 renderer back-ends
2019-09-25 03:25:59 +00:00
static void R_RemoveRenderCommand( void* cmd, int cmdSize )
{
renderCommandList_t* cmdList = &backEndData->commands;
const int endOffset = ((char*)cmd + cmdSize) - (char*)cmdList->cmds;
const int endBytes = cmdList->used - endOffset;
assert( cmd >= cmdList->cmds && ((char*)cmd + cmdSize) <= ((char*)cmdList->cmds + cmdList->used) );
memmove( cmd, (char*)cmd + cmdSize, endBytes );
cmdList->used -= cmdSize;
}
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
/*
============
R_GetCommandBuffer
make sure there is enough command space, waiting on the
render thread if needed.
============
*/
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
void *R_GetCommandBuffer( int bytes, qbool endFrame ) {
const int reservedBytes = (int)( sizeof(swapBuffersCommand_t) + sizeof(screenshotCommand_t) );
const int endOffset = endFrame ? 0 : reservedBytes;
renderCommandList_t* const cmdList = &backEndData->commands;
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
bytes = PAD(bytes, sizeof(void *));
// always leave room for the end of list command
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
if ( cmdList->used + bytes + endOffset > MAX_RENDER_COMMANDS ) {
if ( bytes > MAX_RENDER_COMMANDS - endOffset ) {
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
ri.Error( ERR_FATAL, "R_GetCommandBuffer: bad size %i", bytes );
}
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
if ( endFrame ) {
// we reserved memory specifically for this case
// so this really shouldn't ever happen
ri.Error( ERR_FATAL, "R_GetCommandBuffer: can't allocate %i bytes to end the frame", bytes );
}
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
// if we run out of room, just start dropping commands
return NULL;
}
cmdList->used += bytes;
return cmdList->cmds + cmdList->used - bytes;
}
// technically, all commands should probably check tr.registered
// but realistically, only begin+end frame really need to
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
#define R_CMD_RET(T, ID) T* cmd = (T*)R_GetCommandBuffer( sizeof(T), qfalse ); if (!cmd) return; cmd->commandId = ID
#define R_CMD_NORET(T, ID) T* cmd = (T*)R_GetCommandBuffer( sizeof(T), qfalse ); if (cmd) cmd->commandId = ID
#define R_CMD_END(T, ID) T* cmd = (T*)R_GetCommandBuffer( sizeof(T), qtrue ); cmd->commandId = ID
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
added OpenGL 3.2 and Direct3D 11 renderer back-ends
2019-09-25 03:25:59 +00:00
void R_AddDrawSurfCmd( drawSurf_t* drawSurfs, int numDrawSurfs, int numTranspSurfs )
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
{
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_RET( drawSurfsCommand_t, RC_DRAW_SURFS );
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
cmd->drawSurfs = drawSurfs;
cmd->numDrawSurfs = numDrawSurfs;
added OpenGL 3.2 and Direct3D 11 renderer back-ends
2019-09-25 03:25:59 +00:00
cmd->numTranspSurfs = numTranspSurfs;
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
cmd->refdef = tr.refdef;
cmd->viewParms = tr.viewParms;
}
// passing NULL will set the color to white
void RE_SetColor( const float* rgba )
{
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_RET( setColorCommand_t, RC_SET_COLOR );
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
if ( !rgba )
rgba = colorWhite;
cmd->color[0] = rgba[0];
cmd->color[1] = rgba[1];
cmd->color[2] = rgba[2];
cmd->color[3] = rgba[3];
}
void RE_StretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader )
{
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_RET( stretchPicCommand_t, RC_STRETCH_PIC );
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
cmd->shader = R_GetShaderByHandle( hShader );
cmd->x = x;
cmd->y = y;
cmd->w = w;
cmd->h = h;
cmd->s1 = s1;
cmd->t1 = t1;
cmd->s2 = s2;
cmd->t2 = t2;
}
added help panel and colorized help text added con_drawHelp and con_col* letting the mod know we support the "cap_ExtraColorCodes" extension con_colText overrides ^7 in the console and the help panel extended console back scroll arrows all the way
2017-12-27 04:13:33 +00:00
void RE_DrawTriangle( float x0, float y0, float x1, float y1, float x2, float y2, float s0, float t0, float s1, float t1, float s2, float t2, qhandle_t hShader )
{
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_RET( triangleCommand_t, RC_TRIANGLE );
added help panel and colorized help text added con_drawHelp and con_col* letting the mod know we support the "cap_ExtraColorCodes" extension con_colText overrides ^7 in the console and the help panel extended console back scroll arrows all the way
2017-12-27 04:13:33 +00:00
cmd->shader = R_GetShaderByHandle( hShader );
cmd->x0 = x0;
cmd->y0 = y0;
cmd->x1 = x1;
cmd->y1 = y1;
cmd->x2 = x2;
cmd->y2 = y2;
cmd->s0 = s0;
cmd->t0 = t0;
cmd->s1 = s1;
cmd->t1 = t1;
cmd->s2 = s2;
cmd->t2 = t2;
}
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
// if running in stereo, RE_BeginFrame will be called twice for each RE_EndFrame
void RE_BeginFrame( stereoFrame_t stereoFrame )
{
if (!tr.registered)
return;
tr.frameCount++;
tr.frameSceneNum = 0;
added screenshotnc and screenshotncJPEG
2017-11-05 21:40:32 +00:00
// delayed screenshot
if ( r_delayedScreenshotPending ) {
r_delayedScreenshotFrame++;
if ( r_delayedScreenshotFrame >= 2 ) {
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_NORET( screenshotCommand_t, RC_SCREENSHOT );
added screenshotnc and screenshotncJPEG
2017-11-05 21:40:32 +00:00
*cmd = r_delayedScreenshot;
r_delayedScreenshotPending = qfalse;
r_delayedScreenshotFrame = 0;
}
}
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
//
// draw buffer stuff
//
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_NORET( beginFrameCommand_t, RC_BEGIN_FRAME );
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
}
minimizing disables the rendering back-end except for videos/screenshots when minimized, we call the rest of the logic all the same (including the VM calls) only 1 screenshot command can be issued per frame (i.e. only first one is kept)
2018-01-06 23:03:42 +00:00
void RE_EndFrame( int* pcFE, int* pc2D, int* pc3D, qbool render )
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
{
if (!tr.registered)
return;
minimizing disables the rendering back-end except for videos/screenshots when minimized, we call the rest of the logic all the same (including the VM calls) only 1 screenshot command can be issued per frame (i.e. only first one is kept)
2018-01-06 23:03:42 +00:00
qbool delayScreenshot = qfalse;
if ( !render && r_delayedScreenshotPending )
render = qtrue;
if ( !render ) {
added OpenGL 3.2 and Direct3D 11 renderer back-ends
2019-09-25 03:25:59 +00:00
screenshotCommand_t* ssCmd = (screenshotCommand_t*)R_FindRenderCommand( RC_SCREENSHOT );
minimizing disables the rendering back-end except for videos/screenshots when minimized, we call the rest of the logic all the same (including the VM calls) only 1 screenshot command can be issued per frame (i.e. only first one is kept)
2018-01-06 23:03:42 +00:00
if ( ssCmd )
render = qtrue;
if ( ssCmd && !ssCmd->delayed ) {
// save and remove the command so we can push it back after the frame's done
r_delayedScreenshot = *ssCmd;
r_delayedScreenshot.delayed = qtrue;
added OpenGL 3.2 and Direct3D 11 renderer back-ends
2019-09-25 03:25:59 +00:00
R_RemoveRenderCommand( ssCmd, sizeof(screenshotCommand_t) );
minimizing disables the rendering back-end except for videos/screenshots when minimized, we call the rest of the logic all the same (including the VM calls) only 1 screenshot command can be issued per frame (i.e. only first one is kept)
2018-01-06 23:03:42 +00:00
delayScreenshot = qtrue;
}
}
if ( render ) {
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_END( swapBuffersCommand_t, RC_SWAP_BUFFERS );
minimizing disables the rendering back-end except for videos/screenshots when minimized, we call the rest of the logic all the same (including the VM calls) only 1 screenshot command can be issued per frame (i.e. only first one is kept)
2018-01-06 23:03:42 +00:00
if ( delayScreenshot ) {
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_END( screenshotCommand_t, RC_SCREENSHOT );
minimizing disables the rendering back-end except for videos/screenshots when minimized, we call the rest of the logic all the same (including the VM calls) only 1 screenshot command can be issued per frame (i.e. only first one is kept)
2018-01-06 23:03:42 +00:00
*cmd = r_delayedScreenshot;
}
} else {
R_ClearFrame();
}
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
R_IssueRenderCommands();
deleted 2-threads rendering support (SMP)
2017-11-03 18:34:32 +00:00
R_ClearFrame();
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
if (pcFE)
Com_Memcpy( pcFE, &tr.pc, sizeof( tr.pc ) );
if (pc2D)
Com_Memcpy( pc2D, &backEnd.pc2D, sizeof( backEnd.pc2D ) );
if (pc3D)
Com_Memcpy( pc3D, &backEnd.pc3D, sizeof( backEnd.pc3D ) );
Com_Memset( &tr.pc, 0, sizeof( tr.pc ) );
Com_Memset( &backEnd.pc2D, 0, sizeof( backEnd.pc2D ) );
Com_Memset( &backEnd.pc3D, 0, sizeof( backEnd.pc3D ) );
}
void RE_TakeVideoFrame( int width, int height, byte *captureBuffer, byte *encodeBuffer, qbool motionJpeg )
{
fixed crashes due to render command list overflows also increased the buffer's size (e.g. to draw all chars in the console in 4K) one of the crashes happens in R_SortDrawSurfs: -> render command list is too full -> RE_EndFrame returns early because it can't allocate RC_SWAP_BUFFERS -> R_ClearFrame in RE_EndFrame doesn't get called -> the next frame starts with r_firstSceneDrawSurf etc. not being reset to 0 -> r_firstSceneDrawSurf becomes really close to the maximum draw surface limit -> the draw surface list is iterated incorrectly (no wrapping handled) -> we fetch a draw surface we shouldn't -> its sort key gets decoded and we get an invalid sorted shader index -> we fetch a NULL shader at that index location -> we attempt to read shader->sort -> we crash reading address 76 -> 76 bytes is exactly the offset of the sort member into the shader_t struct
2020-05-08 01:38:26 +00:00
R_CMD_RET( videoFrameCommand_t, RC_VIDEOFRAME );
import from cnq3 1.47
2016-12-18 04:43:04 +00:00
cmd->width = width;
cmd->height = height;
cmd->captureBuffer = captureBuffer;
cmd->encodeBuffer = encodeBuffer;
cmd->motionJpeg = motionJpeg;
}
Reference in a new issue Copy permalink