zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2024-11-28 23:12:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
qzdoom/src/v_draw.cpp

1457 lines
37 KiB
C++
Raw Normal View History

Normalize line endings
2016-03-01 15:47:10 +00:00
/*
** v_draw.cpp
** Draw patches and blocks to a canvas
**
**---------------------------------------------------------------------------
** Copyright 1998-2008 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
#include <stdio.h>
#include <stdarg.h>
#include "doomtype.h"
#include "v_video.h"
#include "r_defs.h"
#include "r_utility.h"
Move software canvas drawing to its own file in the software renderer
2017-02-13 16:32:52 +00:00
#include "r_renderer.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "doomstat.h"
#include "gi.h"
#include "g_level.h"
#include "sbar.h"
- moved the screen blending code out of the renderer. This is better be made part of the 2D interface. That would have been done long ago if it hadn't been for the totally incompatible way this was handled by the purely paletted software renderer. Now with that out of the way there is no point keeping this code this deeply embedded in the renderer.
2018-05-05 09:20:37 +00:00
#include "d_player.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "i_video.h"
- refactored global sides array to be more VM friendly. - moved FLevelLocals to its own header to resolve some circular include conflicts.
2017-01-08 17:45:30 +00:00
#include "g_levellocals.h"
- moved the VM types into their own file and only include it where really needed.
2017-04-12 23:12:04 +00:00
#include "vm.h"
- refactoring of fixed colormap stuff to have it better organized and to reduce the number of uniforms in the main shader. This removes 3 uniforms, consisting of 9 floats. Those were merged into other values that never get used at the same time. It also moves the costly setup of the fixed colormap out of the render state into the 2D processing code. Since 3D forces use of render buffers now, it is no longer necessary to draw the entire scene with the colormap active, meaning it can be handled more efficiently.
2018-06-16 11:47:24 +00:00
#include "hwrenderer/utility/hw_cvars.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
- moved the screen blending code out of the renderer. This is better be made part of the 2D interface. That would have been done long ago if it hadn't been for the totally incompatible way this was handled by the purely paletted software renderer. Now with that out of the way there is no point keeping this code this deeply embedded in the renderer.
2018-05-05 09:20:37 +00:00
CVAR(Float, underwater_fade_scalar, 1.0f, CVAR_ARCHIVE) // [Nash] user-settable underwater blend intensity
- added a special slider type for the scaling options that prints a descriptive text instead of the slider for the special settings. - fixed the adaptive scale calculation in GetUIScale which had the coordinates mixed up.
2017-03-30 09:30:09 +00:00
CUSTOM_CVAR(Int, uiscale, 0, CVAR_ARCHIVE | CVAR_NOINITCALL)
Add uiscale slider controlling what scale the On setting uses for hud_scale, hud_althudscale and con_scaletext
2016-09-06 17:48:14 +00:00
{
- implemented proper scaling for the status bar itself. This allows using the UI scale or its own value, like all other scaling values. In addition there is a choice between preserving equal pixel size or aspect ratio because the squashed non-corrected versions tend to look odd, but since proper scaling requires ununiform pixel sizes it is an option. - changed how status bar sizes are being handled. This has to recalculate all scaling and positioning factors, which can cause problems if the drawer leaves with some temporary values that do not reflect the status bar as a whole. Changed it so that the status bar stores the base values and restores them after drawing is complete.
2017-03-29 17:23:40 +00:00
if (self < 0)
{
self = 0;
return;
}
Add uiscale slider controlling what scale the On setting uses for hud_scale, hud_althudscale and con_scaletext
2016-09-06 17:48:14 +00:00
if (StatusBar != NULL)
{
- scriptified the main statusbar interface and the Strife status bar. Note that the Strife status bar does not draw the health bars yet. I tried to replace the hacky custom texture with a single fill operation but had to find out that all the coordinate mangling for the status bar is being done deep in the video code. This needs to be fixed before this can be made to work. Currently this is not usable in mods because they cannot initialize custom status bars yet.
2017-03-21 19:09:09 +00:00
StatusBar->CallScreenSizeChanged();
Add uiscale slider controlling what scale the On setting uses for hud_scale, hud_althudscale and con_scaletext
2016-09-06 17:48:14 +00:00
}
- fix last commit - somehow it pushed an old version of the fix (yet again?...) - this is the proper fix.
2017-08-19 10:02:56 +00:00
setsizeneeded = true;
Add uiscale slider controlling what scale the On setting uses for hud_scale, hud_althudscale and con_scaletext
2016-09-06 17:48:14 +00:00
}
cleaned up the scaling options. - all 5 settings affected by uiscale have been changed to have the exact same semantics: -1, if supported means special scaling, this is available for HUD and status bar, 0 means to use uiscale, any larger value is a direct scaling factor. - scaling is cut off when the factor is larger than screenwidth/320 or screenheight/200 because anything larger will definitely not fit. - a lot of code has been cleaned up and consolidated. Especially the message code had an incredible amount of redundancy. - all scaling options have been moved into a submenu. This menu is not complete, though - it still requires a special menu widget to convey the intended information without confusing the user.
2017-03-30 00:16:23 +00:00
int GetUIScale(int altval)
{
int scaleval;
if (altval > 0) scaleval = altval;
else if (uiscale == 0)
{
- added a special slider type for the scaling options that prints a descriptive text instead of the slider for the special settings. - fixed the adaptive scale calculation in GetUIScale which had the coordinates mixed up.
2017-03-30 09:30:09 +00:00
// Default should try to scale to 640x400
int vscale = screen->GetHeight() / 400;
int hscale = screen->GetWidth() / 640;
cleaned up the scaling options. - all 5 settings affected by uiscale have been changed to have the exact same semantics: -1, if supported means special scaling, this is available for HUD and status bar, 0 means to use uiscale, any larger value is a direct scaling factor. - scaling is cut off when the factor is larger than screenwidth/320 or screenheight/200 because anything larger will definitely not fit. - a lot of code has been cleaned up and consolidated. Especially the message code had an incredible amount of redundancy. - all scaling options have been moved into a submenu. This menu is not complete, though - it still requires a special menu widget to convey the intended information without confusing the user.
2017-03-30 00:16:23 +00:00
scaleval = clamp(vscale, 1, hscale);
}
else scaleval = uiscale;
// block scales that result in something larger than the current screen.
int vmax = screen->GetHeight() / 200;
int hmax = screen->GetWidth() / 320;
int max = MAX(vmax, hmax);
- fixed: Prevent /0 errors when calculating console scale, which could happen in certain rare situations.
2017-06-20 03:46:07 +00:00
return MAX(1,MIN(scaleval, max));
cleaned up the scaling options. - all 5 settings affected by uiscale have been changed to have the exact same semantics: -1, if supported means special scaling, this is available for HUD and status bar, 0 means to use uiscale, any larger value is a direct scaling factor. - scaling is cut off when the factor is larger than screenwidth/320 or screenheight/200 because anything larger will definitely not fit. - a lot of code has been cleaned up and consolidated. Especially the message code had an incredible amount of redundancy. - all scaling options have been moved into a submenu. This menu is not complete, though - it still requires a special menu widget to convey the intended information without confusing the user.
2017-03-30 00:16:23 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] Stretch values to make a 320x200 image best fit the screen
// without using fractional steppings
int CleanXfac, CleanYfac;
// [RH] Effective screen sizes that the above scale values give you
int CleanWidth, CleanHeight;
// Above minus 1 (or 1, if they are already 1)
int CleanXfac_1, CleanYfac_1, CleanWidth_1, CleanHeight_1;
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// ZScript wrappers for inlines
//
//==========================================================================
- exported some stuff for fonts and screen size that will be needed for the menus.
2017-02-03 23:46:22 +00:00
DEFINE_ACTION_FUNCTION(_Screen, GetWidth)
{
PARAM_PROLOGUE;
ACTION_RETURN_INT(screen->GetWidth());
}
DEFINE_ACTION_FUNCTION(_Screen, GetHeight)
{
PARAM_PROLOGUE;
ACTION_RETURN_INT(screen->GetHeight());
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- the first menu function has been scriptified.
2017-02-09 23:25:50 +00:00
DEFINE_ACTION_FUNCTION(_Screen, PaletteColor)
{
PARAM_PROLOGUE;
PARAM_INT(index);
if (index < 0 || index > 255) index = 0;
else index = GPalette.BaseColors[index];
ACTION_RETURN_INT(index);
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// Internal texture drawing function
//
//==========================================================================
void DFrameBuffer::DrawTexture (FTexture *img, double x, double y, int tags_first, ...)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
Va_List tags;
va_start(tags.list, tags_first);
- changed DrawTexture so that the parameters get parsed in the varargs function directly and that the virtual function that is getting called gets the fully prepared data. In order to avoid passing around tag lists, DrawTextV needs to parse everything itself and then pass a fully initialized structure to DrawTexture. This cannot be done if all variants require a varargs tag list. Apparently the only reason for the old approach was the 'hw' parameter which was never used.
2016-04-09 10:55:12 +00:00
DrawParms parms;
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
bool res = ParseDrawTextureTags(img, x, y, tags_first, tags, &parms, false);
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
va_end(tags.list);
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
if (!res)
- changed DrawTexture so that the parameters get parsed in the varargs function directly and that the virtual function that is getting called gets the fully prepared data. In order to avoid passing around tag lists, DrawTextV needs to parse everything itself and then pass a fully initialized structure to DrawTexture. This cannot be done if all variants require a varargs tag list. Apparently the only reason for the old approach was the 'hw' parameter which was never used.
2016-04-09 10:55:12 +00:00
{
return;
}
- removed the unused x and y parameters from DrawTextureParms.
2016-04-09 10:59:50 +00:00
DrawTextureParms(img, parms);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// ZScript texture drawing function
//
//==========================================================================
- exported DrawChar and DrawText.
2017-02-05 15:47:33 +00:00
int ListGetInt(VMVa_List &tags);
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::DrawTexture(FTexture *img, double x, double y, VMVa_List &args)
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
{
DrawParms parms;
uint32_t tag = ListGetInt(args);
bool res = ParseDrawTextureTags(img, x, y, tag, args, &parms, false);
if (!res) return;
DrawTextureParms(img, parms);
}
DEFINE_ACTION_FUNCTION(_Screen, DrawTexture)
{
PARAM_PROLOGUE;
PARAM_INT(texid);
PARAM_BOOL(animate);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
- added DFrameBuffer::HasBegun2D to allow scripting to test if 2D drawing is active (instead of using IsLocked, which may return false when vid_hw2d is active)
2017-03-28 22:45:53 +00:00
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
- added safeguards to all 2D drawing functions to throw an exception if used outside a valid 2D draw context. This is necessary because the hardware accelerated renderers will hide the problem, but with pure software rendering to a locked hardware surface, like DirectDraw can result in a crash. Note that ANY mod that gets caught in this did something wrong!
2017-03-28 11:25:17 +00:00
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
FTexture *tex = animate ? TexMan(FSetTextureID(texid)) : TexMan[FSetTextureID(texid)];
VMVa_List args = { param + 4, 0, numparam - 4 };
screen->DrawTexture(tex, x, y, args);
return 0;
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// common drawing function
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::DrawTextureParms(FTexture *img, DrawParms &parms)
{
- fixed a few things, but still not working.
2018-03-28 21:42:06 +00:00
m2DDrawer.AddTexture(img, parms);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// Clipping rect
//
//==========================================================================
void DFrameBuffer::SetClipRect(int x, int y, int w, int h)
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
{
clipleft = clamp(x, 0, GetWidth());
- fixed: For Screen.SetClipRect, -1 is a valid value for width and height so it must not be clamped away.
2017-04-14 13:41:36 +00:00
clipwidth = clamp(w, -1, GetWidth() - x);
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
cliptop = clamp(y, 0, GetHeight());
- fixed: For Screen.SetClipRect, -1 is a valid value for width and height so it must not be clamped away.
2017-04-14 13:41:36 +00:00
clipheight = clamp(h, -1, GetHeight() - y);
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
}
- exported the clipping rectangle to scripting and added a statusbar scaling wrapper for it. - fixed: BaseStatusBar.Fill did not pass its flags parameter to the native function.
2017-03-30 10:13:28 +00:00
DEFINE_ACTION_FUNCTION(_Screen, SetClipRect)
{
PARAM_PROLOGUE;
PARAM_INT(x);
PARAM_INT(y);
PARAM_INT(w);
PARAM_INT(h);
screen->SetClipRect(x, y, w, h);
return 0;
}
DEFINE_ACTION_FUNCTION(_Screen, ClearClipRect)
{
PARAM_PROLOGUE;
screen->ClearClipRect();
return 0;
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::GetClipRect(int *x, int *y, int *w, int *h)
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
{
if (x) *x = clipleft;
if (y) *y = cliptop;
if (w) *w = clipwidth;
if (h) *h = clipheight;
}
- exported the clipping rectangle to scripting and added a statusbar scaling wrapper for it. - fixed: BaseStatusBar.Fill did not pass its flags parameter to the native function.
2017-03-30 10:13:28 +00:00
DEFINE_ACTION_FUNCTION(_Screen, GetClipRect)
{
PARAM_PROLOGUE;
int x, y, w, h;
screen->GetClipRect(&x, &y, &w, &h);
if (numret > 0) ret[0].SetInt(x);
- fixed some issues with Set/GetClipRect.
2017-03-30 19:12:39 +00:00
if (numret > 1) ret[1].SetInt(y);
if (numret > 2) ret[2].SetInt(w);
if (numret > 3) ret[3].SetInt(h);
- exported the clipping rectangle to scripting and added a statusbar scaling wrapper for it. - fixed: BaseStatusBar.Fill did not pass its flags parameter to the native function.
2017-03-30 10:13:28 +00:00
return MIN(numret, 4);
}
- added Screen.getViewWindow function
2018-01-20 20:02:36 +00:00
DEFINE_ACTION_FUNCTION(_Screen, GetViewWindow)
{
PARAM_PROLOGUE;
if (numret > 0) ret[0].SetInt(viewwindowx);
if (numret > 1) ret[1].SetInt(viewwindowy);
if (numret > 2) ret[2].SetInt(viewwidth);
if (numret > 3) ret[3].SetInt(viewheight);
return MIN(numret, 4);
}
- exported the clipping rectangle to scripting and added a statusbar scaling wrapper for it. - fixed: BaseStatusBar.Fill did not pass its flags parameter to the native function.
2017-03-30 10:13:28 +00:00
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// Draw parameter parsing
//
//==========================================================================
bool DFrameBuffer::SetTextureParms(DrawParms *parms, FTexture *img, double xx, double yy) const
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
{
if (img != NULL)
{
parms->x = xx;
parms->y = yy;
parms->texwidth = img->GetScaledWidthDouble();
parms->texheight = img->GetScaledHeightDouble();
if (parms->top == INT_MAX || parms->fortext)
{
- made SPROFS a more usable feature. This was originally invented to fix the sprite offsets for the hardware renderer. Changed it so that it doesn't override the original offsets but acts as a second set. A new CVAR has been added to allow controlling the behavior per renderer.
2018-03-31 08:37:46 +00:00
parms->top = img->GetScaledTopOffset(0);
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
}
if (parms->left == INT_MAX || parms->fortext)
{
- made SPROFS a more usable feature. This was originally invented to fix the sprite offsets for the hardware renderer. Changed it so that it doesn't override the original offsets but acts as a second set. A new CVAR has been added to allow controlling the behavior per renderer.
2018-03-31 08:37:46 +00:00
parms->left = img->GetScaledLeftOffset(0);
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
}
if (parms->destwidth == INT_MAX || parms->fortext)
{
parms->destwidth = img->GetScaledWidthDouble();
}
if (parms->destheight == INT_MAX || parms->fortext)
{
parms->destheight = img->GetScaledHeightDouble();
}
switch (parms->cleanmode)
{
default:
break;
case DTA_Clean:
parms->x = (parms->x - 160.0) * CleanXfac + (Width * 0.5);
parms->y = (parms->y - 100.0) * CleanYfac + (Height * 0.5);
parms->destwidth = parms->texwidth * CleanXfac;
parms->destheight = parms->texheight * CleanYfac;
break;
case DTA_CleanNoMove:
parms->destwidth = parms->texwidth * CleanXfac;
parms->destheight = parms->texheight * CleanYfac;
break;
case DTA_CleanNoMove_1:
parms->destwidth = parms->texwidth * CleanXfac_1;
parms->destheight = parms->texheight * CleanYfac_1;
break;
case DTA_Fullscreen:
parms->x = parms->y = 0;
break;
case DTA_HUDRules:
case DTA_HUDRulesC:
{
- let hud_scale act like an override to uiscale, just like con_scale does. - better handling of ForceScale for the fullscreen HUD that doesn't mess around with CVARs. - moved the mug shot into the status bar, because this is global state that needs to be shared between different pieces of code which want to display a mug shot. - SBARINFO should work off the current status bar settings instead of the ones stored in its script object
2017-03-25 17:31:53 +00:00
// Note that this has been deprecated because the HUD should be drawn by the status bar.
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
bool xright = parms->x < 0;
bool ybot = parms->y < 0;
- let hud_scale act like an override to uiscale, just like con_scale does. - better handling of ForceScale for the fullscreen HUD that doesn't mess around with CVARs. - moved the mug shot into the status bar, because this is global state that needs to be shared between different pieces of code which want to display a mug shot. - SBARINFO should work off the current status bar settings instead of the ones stored in its script object
2017-03-25 17:31:53 +00:00
DVector2 scale = StatusBar->GetHUDScale();
parms->x *= scale.X;
if (parms->cleanmode == DTA_HUDRulesC)
parms->x += Width * 0.5;
else if (xright)
parms->x = Width + parms->x;
parms->y *= scale.Y;
if (ybot)
parms->y = Height + parms->y;
parms->destwidth = parms->texwidth * scale.X;
parms->destheight = parms->texheight * scale.Y;
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
break;
}
}
if (parms->virtWidth != Width || parms->virtHeight != Height)
{
VirtualToRealCoords(parms->x, parms->y, parms->destwidth, parms->destheight,
parms->virtWidth, parms->virtHeight, parms->virtBottom, !parms->keepratio);
}
}
- fixed: The software 2D drawer expected its translation pointer to be initialized by ParseDrawTextureTags. Removed the variable from DrawParms and made it and its initialization local to the software rendering code.
2016-04-09 20:56:12 +00:00
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
return false;
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// template helpers
//
//==========================================================================
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
static void ListEnd(Va_List &tags)
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
{
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
va_end(tags.list);
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
}
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
static int ListGetInt(Va_List &tags)
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
{
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
return va_arg(tags.list, int);
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
}
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
static inline double ListGetDouble(Va_List &tags)
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
{
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
return va_arg(tags.list, double);
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
}
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
static inline FSpecialColormap * ListGetSpecialColormap(Va_List &tags)
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
{
- wrap the va_list that gets passed around by the Draw functions into a struct so that the templates can use reliable, identical semantics for both this and the VM's arg list.
2017-02-05 20:54:09 +00:00
return va_arg(tags.list, FSpecialColormap *);
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
}
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
static void ListEnd(VMVa_List &tags)
{
}
- exported DrawChar and DrawText.
2017-02-05 15:47:33 +00:00
int ListGetInt(VMVa_List &tags)
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
{
- exported the drawer function of the colorpicker menu.
2017-02-10 12:20:19 +00:00
if (tags.curindex < tags.numargs)
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
{
- exported the drawer function of the colorpicker menu.
2017-02-10 12:20:19 +00:00
if (tags.args[tags.curindex].Type == REGT_INT)
{
return tags.args[tags.curindex++].i;
}
ThrowAbortException(X_OTHER, "Invalid parameter in draw function, int expected");
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
}
- exported the drawer function of the colorpicker menu.
2017-02-10 12:20:19 +00:00
return TAG_DONE;
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
}
static inline double ListGetDouble(VMVa_List &tags)
{
if (tags.curindex < tags.numargs && tags.args[tags.curindex].Type == REGT_FLOAT)
{
return tags.args[tags.curindex++].f;
}
ThrowAbortException(X_OTHER, "Invalid parameter in draw function, float expected");
return 0;
}
static inline FSpecialColormap * ListGetSpecialColormap(VMVa_List &tags)
{
ThrowAbortException(X_OTHER, "Invalid tag in draw function");
return nullptr;
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// Main taglist parsing
//
//==========================================================================
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
template<class T>
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
bool DFrameBuffer::ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const
Normalize line endings
2016-03-01 15:47:10 +00:00
{
INTBOOL boolval;
int intval;
bool translationset = false;
bool fillcolorset = false;
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
if (!fortext)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- renamed FTexture's UseType flags and gave them a dedicated type. This was done mainly to reduce the amount of occurences of the word FTexture but it immediately helped detect two small and mostly harmless bugs that were found due to the stricter type checks.
2018-03-25 18:26:16 +00:00
if (img == NULL || img->UseType == ETextureType::Null)
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
{
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
ListEnd(tags);
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
return false;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// Do some sanity checks on the coordinates.
if (x < -16383 || x > 16383 || y < -16383 || y > 16383)
{
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
ListEnd(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
return false;
}
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->fortext = fortext;
Normalize line endings
2016-03-01 15:47:10 +00:00
parms->windowleft = 0;
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->windowright = INT_MAX;
Normalize line endings
2016-03-01 15:47:10 +00:00
parms->dclip = this->GetHeight();
parms->uclip = 0;
parms->lclip = 0;
parms->rclip = this->GetWidth();
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->left = INT_MAX;
parms->top = INT_MAX;
parms->destwidth = INT_MAX;
parms->destheight = INT_MAX;
- floatification of some alpha parameters.
2016-03-22 12:35:16 +00:00
parms->Alpha = 1.f;
Normalize line endings
2016-03-01 15:47:10 +00:00
parms->fillcolor = -1;
parms->remap = NULL;
parms->colorOverlay = 0;
parms->alphaChannel = false;
parms->flipX = false;
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
parms->flipY = false;
- added colorization for untranslated fonts. This uses the light color of the vertices. The software rendered 2D code will ignore this infomation. - added a virtual OnRetrun method to menus.
2017-03-29 19:22:05 +00:00
parms->color = 0xffffffff;
- added DAMAGE_NO_ARMOR flag for ACS's SectorDamage function.
2017-02-25 18:10:49 +00:00
//parms->shadowAlpha = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
parms->shadowColor = 0;
parms->virtWidth = this->GetWidth();
parms->virtHeight = this->GetHeight();
parms->keepratio = false;
parms->style.BlendOp = 255; // Dummy "not set" value
parms->masked = true;
parms->bilinear = false;
parms->specialcolormap = NULL;
- 2D drawer implementation complete for hardware renderer. This also replaces DTA_ColormapStyle with proper implementations of its components. As implemented it was a very awkward mixture of various effects that already existed in a separate form. As a result of its implementation it required additional but completely redundant shader support which could be removed now. As a side effect of this change a new DTA_Desaturate option was added.
2018-03-29 14:21:21 +00:00
parms->desaturate = 0;
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->cleanmode = DTA_Base;
parms->scalex = parms->scaley = 1;
parms->cellx = parms->celly = 0;
parms->maxstrlen = INT_MAX;
parms->virtBottom = false;
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
parms->srcx = 0.;
parms->srcy = 0.;
parms->srcwidth = 1.;
parms->srcheight = 1.;
Normalize line endings
2016-03-01 15:47:10 +00:00
// Parse the tag list for attributes. (For floating point attributes,
// consider that the C ABI dictates that all floats be promoted to
// doubles when passed as function arguments.)
while (tag != TAG_DONE)
{
switch (tag)
{
default:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_DestWidth:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
parms->cleanmode = DTA_Base;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->destwidth = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_DestWidthF:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
parms->cleanmode = DTA_Base;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->destwidth = ListGetDouble(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_DestHeight:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
parms->cleanmode = DTA_Base;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->destheight = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_DestHeightF:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
parms->cleanmode = DTA_Base;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->destheight = ListGetDouble(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_Clean:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
boolval = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (boolval)
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->scalex = 1;
parms->scaley = 1;
parms->cleanmode = tag;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
break;
case DTA_CleanNoMove:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
boolval = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (boolval)
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->scalex = CleanXfac;
parms->scaley = CleanYfac;
parms->cleanmode = tag;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
break;
case DTA_CleanNoMove_1:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
boolval = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (boolval)
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->scalex = CleanXfac_1;
parms->scaley = CleanYfac_1;
parms->cleanmode = tag;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
break;
case DTA_320x200:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
boolval = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (boolval)
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->cleanmode = DTA_Base;
parms->scalex = 1;
parms->scaley = 1;
Normalize line endings
2016-03-01 15:47:10 +00:00
parms->virtWidth = 320;
parms->virtHeight = 200;
}
break;
case DTA_Bottom320x200:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
boolval = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (boolval)
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->cleanmode = DTA_Base;
parms->scalex = 1;
parms->scaley = 1;
Normalize line endings
2016-03-01 15:47:10 +00:00
parms->virtWidth = 320;
parms->virtHeight = 200;
}
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->virtBottom = true;
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_HUDRules:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
intval = ListGetInt(tags);
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->cleanmode = intval == HUD_HorizCenter ? DTA_HUDRulesC : DTA_HUDRules;
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_VirtualWidth:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->cleanmode = DTA_Base;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->virtWidth = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_VirtualWidthF:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->cleanmode = DTA_Base;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->virtWidth = ListGetDouble(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
case DTA_VirtualHeight:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->cleanmode = DTA_Base;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->virtHeight = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_VirtualHeightF:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->cleanmode = DTA_Base;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->virtHeight = ListGetDouble(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_Fullscreen:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
boolval = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (boolval)
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (img == NULL) return false;
parms->cleanmode = DTA_Fullscreen;
Normalize line endings
2016-03-01 15:47:10 +00:00
parms->virtWidth = img->GetScaledWidthDouble();
parms->virtHeight = img->GetScaledHeightDouble();
}
break;
case DTA_Alpha:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->Alpha = (float)(MIN<double>(1., ListGetDouble(tags)));
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_AlphaChannel:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->alphaChannel = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_FillColor:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->fillcolor = ListGetInt(tags);
Fixed compilation warning reported by GCC/Clang src/v_draw.cpp:503:25: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare]
2017-03-26 19:04:04 +00:00
if (parms->fillcolor != ~0u)
- major progress on the status bar code: SBARINFO's DrawGraphic has been ported into a generic function of the base statusbar class and put to use for a few items on the Strife status bar. - decided to ditch the widget system I had started to lay out. As it turns out that would make things far more complicated and slower than they need to be.
2017-03-23 14:18:09 +00:00
{
fillcolorset = true;
}
else if (parms->fillcolor != 0)
{
// The crosshair is the only thing which uses a non-black fill color.
parms->fillcolor = PalEntry(ColorMatcher.Pick(parms->fillcolor), RPART(parms->fillcolor), GPART(parms->fillcolor), BPART(parms->fillcolor));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
- removed all uses of DTA_Translation except for the single one that passes a custom built table. This means that with the exception of 3 pointers the DrawTexture interface only accepts numeric values now. Still need to get rid of the last 3 to have this ready for scripting.
2017-02-04 22:26:28 +00:00
case DTA_TranslationIndex:
parms->remap = TranslationToTable(ListGetInt(tags));
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_ColorOverlay:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->colorOverlay = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
- added colorization for untranslated fonts. This uses the light color of the vertices. The software rendered 2D code will ignore this infomation. - added a virtual OnRetrun method to menus.
2017-03-29 19:22:05 +00:00
case DTA_Color:
parms->color = ListGetInt(tags);
break;
Normalize line endings
2016-03-01 15:47:10 +00:00
case DTA_FlipX:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->flipX = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
case DTA_FlipY:
parms->flipY = ListGetInt(tags);
break;
case DTA_SrcX:
parms->srcx = ListGetDouble(tags) / img->GetScaledWidthDouble();
break;
case DTA_SrcY:
parms->srcy = ListGetDouble(tags) / img->GetScaledHeightDouble();
break;
case DTA_SrcWidth:
parms->srcwidth = ListGetDouble(tags) / img->GetScaledWidthDouble();
break;
case DTA_SrcHeight:
parms->srcheight = ListGetDouble(tags) / img->GetScaledHeightDouble();
break;
Normalize line endings
2016-03-01 15:47:10 +00:00
case DTA_TopOffset:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->top = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_TopOffsetF:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->top = ListGetDouble(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_LeftOffset:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->left = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_LeftOffsetF:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->left = ListGetDouble(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_CenterOffset:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
if (ListGetInt(tags))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->left = img->GetScaledWidthDouble() * 0.5;
parms->top = img->GetScaledHeightDouble() * 0.5;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
break;
case DTA_CenterBottomOffset:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
if (ListGetInt(tags))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
parms->left = img->GetScaledWidthDouble() * 0.5;
parms->top = img->GetScaledHeightDouble();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
break;
case DTA_WindowLeft:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->windowleft = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_WindowLeftF:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->windowleft = ListGetDouble(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_WindowRight:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->windowright = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_WindowRightF:
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
assert(fortext == false);
if (fortext) return false;
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->windowright = ListGetDouble(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_ClipTop:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->uclip = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (parms->uclip < 0)
{
parms->uclip = 0;
}
break;
case DTA_ClipBottom:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->dclip = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (parms->dclip > this->GetHeight())
{
parms->dclip = this->GetHeight();
}
break;
case DTA_ClipLeft:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->lclip = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (parms->lclip < 0)
{
parms->lclip = 0;
}
break;
case DTA_ClipRight:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->rclip = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (parms->rclip > this->GetWidth())
{
parms->rclip = this->GetWidth();
}
break;
case DTA_ShadowAlpha:
- added DAMAGE_NO_ARMOR flag for ACS's SectorDamage function.
2017-02-25 18:10:49 +00:00
//parms->shadowAlpha = (float)MIN(1., ListGetDouble(tags));
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_ShadowColor:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->shadowColor = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_Shadow:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
boolval = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (boolval)
{
- added DAMAGE_NO_ARMOR flag for ACS's SectorDamage function.
2017-02-25 18:10:49 +00:00
//parms->shadowAlpha = 0.5;
Normalize line endings
2016-03-01 15:47:10 +00:00
parms->shadowColor = 0;
}
else
{
- added DAMAGE_NO_ARMOR flag for ACS's SectorDamage function.
2017-02-25 18:10:49 +00:00
//parms->shadowAlpha = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
break;
case DTA_Masked:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->masked = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_BilinearFilter:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->bilinear = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_KeepRatio:
// I think this is a terribly misleading name, since it actually turns
// *off* aspect ratio correction.
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->keepratio = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_RenderStyle:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->style.AsDWORD = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case DTA_SpecialColormap:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->specialcolormap = ListGetSpecialColormap(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
- 2D drawer implementation complete for hardware renderer. This also replaces DTA_ColormapStyle with proper implementations of its components. As implemented it was a very awkward mixture of various effects that already existed in a separate form. As a result of its implementation it required additional but completely redundant shader support which could be removed now. As a side effect of this change a new DTA_Desaturate option was added.
2018-03-29 14:21:21 +00:00
case DTA_Desaturate:
parms->desaturate = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
case DTA_TextLen:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->maxstrlen = ListGetInt(tags);
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
break;
case DTA_CellX:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->cellx = ListGetInt(tags);
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
break;
case DTA_CellY:
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
parms->celly = ListGetInt(tags);
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
break;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- did some preparations to ParseDrawTextureTags to allow using the same code for parsing tag lists generated by the VM. - removed the fixed point alpha tag from DrawTexture and replaced all uses with the floating point version.
2017-02-04 12:11:12 +00:00
tag = ListGetInt(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
ListEnd(tags);
Normalize line endings
2016-03-01 15:47:10 +00:00
- use DrawChar to draw font characters instead of calling DrawTexture directly. Mostly done to remove uses of DTA_Translation.
2017-02-04 21:50:23 +00:00
if (parms->remap != nullptr && parms->remap->Inactive)
{ // If it's inactive, pretend we were passed NULL instead.
parms->remap = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
// intersect with the canvas's clipping rectangle.
if (clipwidth >= 0 && clipheight >= 0)
{
if (parms->lclip < clipleft) parms->lclip = clipleft;
if (parms->rclip > clipleft + clipwidth) parms->rclip = clipleft + clipwidth;
if (parms->uclip < cliptop) parms->uclip = cliptop;
- fixed calculation of clipping rect's lower edge.
2017-04-23 10:58:40 +00:00
if (parms->dclip > cliptop + clipheight) parms->dclip = cliptop + clipheight;
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
if (parms->uclip >= parms->dclip || parms->lclip >= parms->rclip)
{
return false;
}
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
if (img != NULL)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
SetTextureParms(parms, img, x, y);
Normalize line endings
2016-03-01 15:47:10 +00:00
- refactored the use of tag lists so that they do not have to be passed around between functions. This means that the varargs functions themselves are now responsible for parsing them into DrawParms. This was done because DrawTextV made a blanket assumption that every single vararg has the size of a 32 bit integer and caused crashes when anything else was passed. It also failed to eliminate any tag that is incompatible with text display. These will now abort DrawText and trigger an assert.
2016-04-09 18:47:54 +00:00
if (parms->destwidth <= 0 || parms->destheight <= 0)
{
return false;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (parms->style.BlendOp == 255)
{
if (fillcolorset)
{
if (parms->alphaChannel)
{
parms->style = STYLE_Shaded;
}
- floatification of some alpha parameters.
2016-03-22 12:35:16 +00:00
else if (parms->Alpha < 1.f)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
parms->style = STYLE_TranslucentStencil;
}
else
{
parms->style = STYLE_Stencil;
}
}
- floatification of some alpha parameters.
2016-03-22 12:35:16 +00:00
else if (parms->Alpha < 1.f)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
parms->style = STYLE_Translucent;
}
else
{
parms->style = STYLE_Normal;
}
}
return true;
}
- exported DrawTexture to scripting. This uses templates to avoid source duplication of ParseDrawTextureTags. Not tested yet.
2017-02-04 21:09:49 +00:00
// explicitly instantiate both versions for v_text.cpp.
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
template bool DFrameBuffer::ParseDrawTextureTags<Va_List>(FTexture *img, double x, double y, uint32_t tag, Va_List& tags, DrawParms *parms, bool fortext) const;
template bool DFrameBuffer::ParseDrawTextureTags<VMVa_List>(FTexture *img, double x, double y, uint32_t tag, VMVa_List& tags, DrawParms *parms, bool fortext) const;
//==========================================================================
//
// Coordinate conversion
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::VirtualToRealCoords(double &x, double &y, double &w, double &h,
Normalize line endings
2016-03-01 15:47:10 +00:00
double vwidth, double vheight, bool vbottom, bool handleaspect) const
{
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
float myratio = handleaspect ? ActiveRatio (Width, Height) : (4.0f / 3.0f);
fix: 21:9 AR stretching in intermission, end level screens
2016-03-02 20:07:11 +00:00
// if 21:9 AR, map to 16:9 for all callers.
// this allows for black bars and stops the stretching of fullscreen images
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
if (myratio > 1.7f) {
myratio = 16.0f / 9.0f;
fix: 21:9 AR stretching in intermission, end level screens
2016-03-02 20:07:11 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
double right = x + w;
double bottom = y + h;
Change canvas rendering to use the aspect ratio of the canvas and generalize 5:4 rendering as AspectTallerThanWide
2016-09-13 21:26:30 +00:00
if (myratio > 1.334f)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // The target surface is either 16:9 or 16:10, so expand the
// specified virtual size to avoid undesired stretching of the
// image. Does not handle non-4:3 virtual sizes. I'll worry about
// those if somebody expresses a desire to use them.
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
x = (x - vwidth * 0.5) * Width * 960 / (vwidth * AspectBaseWidth(myratio)) + Width * 0.5;
w = (right - vwidth * 0.5) * Width * 960 / (vwidth * AspectBaseWidth(myratio)) + Width * 0.5 - x;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
x = x * Width / vwidth;
w = right * Width / vwidth - x;
}
Change canvas rendering to use the aspect ratio of the canvas and generalize 5:4 rendering as AspectTallerThanWide
2016-09-13 21:26:30 +00:00
if (AspectTallerThanWide(myratio))
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // The target surface is 5:4
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
y = (y - vheight * 0.5) * Height * 600 / (vheight * AspectBaseHeight(myratio)) + Height * 0.5;
h = (bottom - vheight * 0.5) * Height * 600 / (vheight * AspectBaseHeight(myratio)) + Height * 0.5 - y;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (vbottom)
{
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
y += (Height - Height * AspectMultiplier(myratio) / 48.0) * 0.5;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else
{
y = y * Height / vheight;
h = bottom * Height / vheight - y;
}
}
- reimplemented the health bar for Strife's status bar.
2017-03-22 13:59:12 +00:00
DEFINE_ACTION_FUNCTION(_Screen, VirtualToRealCoords)
{
PARAM_PROLOGUE;
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(w);
PARAM_FLOAT(h);
PARAM_FLOAT(vw);
PARAM_FLOAT(vh);
PARAM_BOOL_DEF(vbottom);
PARAM_BOOL_DEF(handleaspect);
screen->VirtualToRealCoords(x, y, w, h, vw, vh, vbottom, handleaspect);
if (numret >= 1) ret[0].SetVector2(DVector2(x, y));
if (numret >= 2) ret[1].SetVector2(DVector2(w, h));
return MIN(numret, 2);
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::VirtualToRealCoordsInt(int &x, int &y, int &w, int &h,
Normalize line endings
2016-03-01 15:47:10 +00:00
int vwidth, int vheight, bool vbottom, bool handleaspect) const
{
double dx, dy, dw, dh;
dx = x;
dy = y;
dw = w;
dh = h;
VirtualToRealCoords(dx, dy, dw, dh, vwidth, vheight, vbottom, handleaspect);
x = int(dx + 0.5);
y = int(dy + 0.5);
w = int(dx + dw + 0.5) - x;
h = int(dy + dh + 0.5) - y;
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
//
//
//==========================================================================
void DFrameBuffer::FillBorder (FTexture *img)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
float myratio = ActiveRatio (Width, Height);
21:9 fix for black bars overlapping fullscreen images
2016-03-02 20:33:06 +00:00
// if 21:9 AR, fill borders akin to 16:9, since all fullscreen
// images are being drawn to that scale.
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
if (myratio > 1.7f) {
myratio = 16 / 9.0f;
21:9 fix for black bars overlapping fullscreen images
2016-03-02 20:33:06 +00:00
}
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
if (myratio >= 1.3f && myratio <= 1.4f)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // This is a 4:3 display, so no border to show
return;
}
int bordtop, bordbottom, bordleft, bordright, bord;
Change canvas rendering to use the aspect ratio of the canvas and generalize 5:4 rendering as AspectTallerThanWide
2016-09-13 21:26:30 +00:00
if (AspectTallerThanWide(myratio))
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Screen is taller than it is wide
bordleft = bordright = 0;
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
bord = Height - Height * AspectMultiplier(myratio) / 48;
Normalize line endings
2016-03-01 15:47:10 +00:00
bordtop = bord / 2;
bordbottom = bord - bordtop;
}
else
{ // Screen is wider than it is tall
bordtop = bordbottom = 0;
Switch from ratio enum to float
2016-09-12 13:51:50 +00:00
bord = Width - Width * AspectMultiplier(myratio) / 48;
Normalize line endings
2016-03-01 15:47:10 +00:00
bordleft = bord / 2;
bordright = bord - bordleft;
}
if (img != NULL)
{
FlatFill (0, 0, Width, bordtop, img); // Top
FlatFill (0, bordtop, bordleft, Height - bordbottom, img); // Left
FlatFill (Width - bordright, bordtop, Width, Height - bordbottom, img); // Right
FlatFill (0, Height - bordbottom, Width, Height, img); // Bottom
}
else
{
Clear (0, 0, Width, bordtop, GPalette.BlackIndex, 0); // Top
Clear (0, bordtop, bordleft, Height - bordbottom, GPalette.BlackIndex, 0); // Left
Clear (Width - bordright, bordtop, Width, Height - bordbottom, GPalette.BlackIndex, 0); // Right
Clear (0, Height - bordbottom, Width, Height, GPalette.BlackIndex, 0); // Bottom
}
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// Draw a line
//
//==========================================================================
void DFrameBuffer::DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
m2DDrawer.AddLine(x0, y0, x1, y1, palColor, realcolor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- externalise DCanvas::DrawLine to ZScript
2017-08-03 00:20:55 +00:00
DEFINE_ACTION_FUNCTION(_Screen, DrawLine)
{
PARAM_PROLOGUE;
PARAM_INT(x0);
PARAM_INT(y0);
PARAM_INT(x1);
PARAM_INT(y1);
PARAM_INT(color);
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
- removed ZScript DrawLine palcolor arg
2017-08-03 01:09:48 +00:00
screen->DrawLine(x0, y0, x1, y1, -1, color);
- externalise DCanvas::DrawLine to ZScript
2017-08-03 00:20:55 +00:00
return 0;
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
//
// Draw a single pixel
//
//==========================================================================
void DFrameBuffer::DrawPixel(int x, int y, int palColor, uint32_t realcolor)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
m2DDrawer.AddPixel(x, y, palColor, realcolor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// DCanvas :: Clear
//
// Set an area to a specified color.
//
//==========================================================================
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::Clear(int left, int top, int right, int bottom, int palcolor, uint32_t color)
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
{
if (clipwidth >= 0 && clipheight >= 0)
{
int w = right - left;
int h = bottom - top;
if (left < clipleft)
{
w -= (clipleft - left);
left = clipleft;
}
if (w > clipwidth) w = clipwidth;
if (w <= 0) return;
if (top < cliptop)
{
h -= (cliptop - top);
top = cliptop;
}
if (h > clipheight) w = clipheight;
if (h <= 0) return;
right = left + w;
bottom = top + h;
}
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
if (palcolor >= 0 && color == 0)
{
color = GPalette.BaseColors[palcolor] | 0xff000000;
}
- made the screen blend work for the software renderer. It may use the same calculations as the hardware renderer but must use the 2D drawer for display. It should be investigated if the hardware renderer can do this as well.
2018-04-07 08:53:20 +00:00
m2DDrawer.AddColorOnlyQuad(left, top, right - left, bottom - top, color | 0xFF000000, nullptr);
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
}
- exported the drawer function of the colorpicker menu.
2017-02-10 12:20:19 +00:00
DEFINE_ACTION_FUNCTION(_Screen, Clear)
{
PARAM_PROLOGUE;
PARAM_INT(x1);
PARAM_INT(y1);
PARAM_INT(x2);
PARAM_INT(y2);
PARAM_INT(color);
PARAM_INT_DEF(palcol);
- added DFrameBuffer::HasBegun2D to allow scripting to test if 2D drawing is active (instead of using IsLocked, which may return false when vid_hw2d is active)
2017-03-28 22:45:53 +00:00
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
- exported the drawer function of the colorpicker menu.
2017-02-10 12:20:19 +00:00
screen->Clear(x1, y1, x2, y2, palcol, color);
return 0;
}
- added some helper code mainly designed to help GZDoom maintain the vertex buffer for the textured automap.
2016-08-06 17:20:41 +00:00
Move software canvas drawing to its own file in the software renderer
2017-02-13 16:32:52 +00:00
//==========================================================================
//
// DCanvas :: Dim
//
// Applies a colored overlay to an area of the screen.
//
//==========================================================================
- made the screen blend work for the software renderer. It may use the same calculations as the hardware renderer but must use the 2D drawer for display. It should be investigated if the hardware renderer can do this as well.
2018-04-07 08:53:20 +00:00
void DFrameBuffer::DoDim(PalEntry color, float amount, int x1, int y1, int w, int h, FRenderStyle *style)
Move software canvas drawing to its own file in the software renderer
2017-02-13 16:32:52 +00:00
{
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
if (amount <= 0)
{
return;
}
if (amount > 1)
{
amount = 1;
}
Fixed a few compilation warnings src/gl/renderer/gl_renderer.cpp:775:39: warning: comparison of two values with different enumeration types ('F2DDrawer::ETextureDrawMode' and 'TexMode') [-Wenum-compare] src/gl/renderer/gl_renderer.cpp:776:39: warning: comparison of two values with different enumeration types ('F2DDrawer::ETextureDrawMode' and 'TexMode') [-Wenum-compare] src/gl/renderer/gl_renderer.cpp:777:39: warning: comparison of two values with different enumeration types ('F2DDrawer::ETextureDrawMode' and 'TexMode') [-Wenum-compare] src/gl/renderer/gl_renderer.cpp:778:45: warning: comparison of two values with different enumeration types ('F2DDrawer::ETextureDrawMode' and 'TexMode') [-Wenum-compare] src/gl/renderer/gl_renderer.cpp:779:40: warning: comparison of two values with different enumeration types ('F2DDrawer::ETextureDrawMode' and 'TexMode') [-Wenum-compare] src/gl/renderer/gl_renderer.cpp:780:45: warning: comparison of two values with different enumeration types ('F2DDrawer::ETextureDrawMode' and 'TexMode') [-Wenum-compare] src/v_draw.cpp:1144:51: warning: '&' within '|' [-Wbitwise-op-parentheses] src/textures/texture.cpp:1050:20: warning: comparison of integers of different signs: 'int' and 'unsigned long' [-Wsign-compare] src\intermission\intermission.cpp(80): warning C4101: 'lumpnum': unreferenced local variable
2018-04-08 09:53:41 +00:00
m2DDrawer.AddColorOnlyQuad(x1, y1, w, h, (color.d & 0xffffff) | (int(amount * 255) << 24), style);
Move software canvas drawing to its own file in the software renderer
2017-02-13 16:32:52 +00:00
}
- made the screen blend work for the software renderer. It may use the same calculations as the hardware renderer but must use the 2D drawer for display. It should be investigated if the hardware renderer can do this as well.
2018-04-07 08:53:20 +00:00
void DFrameBuffer::Dim(PalEntry color, float damount, int x1, int y1, int w, int h, FRenderStyle *style)
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
{
if (clipwidth >= 0 && clipheight >= 0)
{
if (x1 < clipleft)
{
w -= (clipleft - x1);
x1 = clipleft;
}
if (w > clipwidth) w = clipwidth;
if (w <= 0) return;
if (y1 < cliptop)
{
h -= (cliptop - y1);
y1 = cliptop;
}
Fixed applying of clip rect to screen dimming https://forum.zdoom.org/viewtopic.php?t=56719
2017-06-05 06:48:09 +00:00
if (h > clipheight) h = clipheight;
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
if (h <= 0) return;
}
- made the screen blend work for the software renderer. It may use the same calculations as the hardware renderer but must use the 2D drawer for display. It should be investigated if the hardware renderer can do this as well.
2018-04-07 08:53:20 +00:00
DoDim(color, damount, x1, y1, w, h, style);
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
}
DEFINE_ACTION_FUNCTION(_Screen, Dim)
{
PARAM_PROLOGUE;
PARAM_INT(color);
PARAM_FLOAT(amount);
PARAM_INT(x1);
PARAM_INT(y1);
PARAM_INT(w);
PARAM_INT(h);
- added DFrameBuffer::HasBegun2D to allow scripting to test if 2D drawing is active (instead of using IsLocked, which may return false when vid_hw2d is active)
2017-03-28 22:45:53 +00:00
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
- added a clipping rectangle to DCanvas that can be used independently of DrawTexture calls. Currently this is only being used for draw operations that are not automap related, i.e. DrawLine, DrawPixel and FillSimplePoly are not subjected to it.
2017-03-28 11:06:24 +00:00
screen->Dim(color, float(amount), x1, y1, w, h);
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// DCanvas :: FillSimplePoly
//
// Fills a simple polygon with a texture. Here, "simple" means that a
// horizontal scanline at any vertical position within the polygon will
// not cross it more than twice.
//
// The originx, originy, scale, and rotation parameters specify
// transformation of the filling texture, not of the points.
//
// The points must be specified in clockwise order.
//
//==========================================================================
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::FillSimplePoly(FTexture *tex, FVector2 *points, int npoints,
- changed angle parameter of FillSimplePoly.
2016-03-24 15:36:43 +00:00
double originx, double originy, double scalex, double scaley, DAngle rotation,
- refactored FDynamicColormap out of sector_t. This has increasingly become an obstacle with the hardware renderer, so now the values are being stored as plain data in the sector, with the software renderer getting the actual color tables when needed. While this is a bit slower than storing the pregenerated colormap, in realistic situations the added time is mostly negligible in the microseconds range.
2017-03-15 15:47:42 +00:00
const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
m2DDrawer.AddPoly(tex, points, npoints, originx, originy, scalex, scaley, rotation, colormap, flatcolor, lightlevel);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
//
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
// DCanvas :: FlatFill
Normalize line endings
2016-03-01 15:47:10 +00:00
//
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
// Fill an area with a texture. If local_origin is false, then the origin
// used for the wrapping is (0,0). Otherwise, (left,right) is used.
//
//==========================================================================
Removed the need for the pixel_canvas_t typedef
2016-05-31 03:31:32 +00:00
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::FlatFill(int left, int top, int right, int bottom, FTexture *src, bool local_origin)
{
- it compiles again. This won't work, though, because no backend for the new 2D code exists yet.
2018-03-28 14:40:09 +00:00
m2DDrawer.AddFlatFill(left, top, right, bottom, src, local_origin);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// V_DrawFrame
//
// Draw a frame around the specified area using the view border
// frame graphics. The border is drawn outside the area, not in it.
//
//==========================================================================
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::DrawFrame (int left, int top, int width, int height)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
FTexture *p;
const gameborder_t *border = &gameinfo.Border;
// Sanity check for incomplete gameinfo
if (border == NULL)
return;
int offset = border->offset;
int right = left + width;
int bottom = top + height;
// Draw top and bottom sides.
p = TexMan[border->t];
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
FlatFill(left, top - p->GetHeight(), right, top, p, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
p = TexMan[border->b];
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
FlatFill(left, bottom, right, bottom + p->GetHeight(), p, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
// Draw left and right sides.
p = TexMan[border->l];
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
FlatFill(left - p->GetWidth(), top, left, bottom, p, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
p = TexMan[border->r];
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
FlatFill(right, top, right + p->GetWidth(), bottom, p, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
// Draw beveled corners.
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
DrawTexture (TexMan[border->tl], left-offset, top-offset, TAG_DONE);
DrawTexture (TexMan[border->tr], left+width, top-offset, TAG_DONE);
DrawTexture (TexMan[border->bl], left-offset, top+height, TAG_DONE);
DrawTexture (TexMan[border->br], left+width, top+height, TAG_DONE);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- all menu items scriptified, but not yet active.
2017-02-11 15:11:48 +00:00
DEFINE_ACTION_FUNCTION(_Screen, DrawFrame)
{
PARAM_PROLOGUE;
PARAM_INT(x);
PARAM_INT(y);
PARAM_INT(w);
PARAM_INT(h);
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
screen->DrawFrame(x, y, w, h);
- all menu items scriptified, but not yet active.
2017-02-11 15:11:48 +00:00
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
// screen->DrawBorder
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::DrawBorder (int x1, int y1, int x2, int y2)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
FTextureID picnum;
if (level.info != NULL && level.info->BorderTexture.Len() != 0)
{
- renamed FTexture's UseType flags and gave them a dedicated type. This was done mainly to reduce the amount of occurences of the word FTexture but it immediately helped detect two small and mostly harmless bugs that were found due to the stricter type checks.
2018-03-25 18:26:16 +00:00
picnum = TexMan.CheckForTexture (level.info->BorderTexture, ETextureType::Flat);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- renamed FTexture's UseType flags and gave them a dedicated type. This was done mainly to reduce the amount of occurences of the word FTexture but it immediately helped detect two small and mostly harmless bugs that were found due to the stricter type checks.
2018-03-25 18:26:16 +00:00
picnum = TexMan.CheckForTexture (gameinfo.BorderFlat, ETextureType::Flat);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (picnum.isValid())
{
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
FlatFill (x1, y1, x2, y2, TexMan(picnum));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
Clear (x1, y1, x2, y2, 0, 0);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//==========================================================================
//
// R_DrawViewBorder
//
// Draws the border around the view for different size windows
//
//==========================================================================
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::DrawViewBorder (void)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
if (viewwidth == Width)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
return;
}
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
DrawBorder (0, 0, Width, viewwindowy);
DrawBorder (0, viewwindowy, viewwindowx, viewheight + viewwindowy);
DrawBorder (viewwindowx + viewwidth, viewwindowy, Width, viewheight + viewwindowy);
DrawBorder (0, viewwindowy + viewheight, Width, StatusBar->GetTopOfStatusbar());
Normalize line endings
2016-03-01 15:47:10 +00:00
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
DrawFrame (viewwindowx, viewwindowy, viewwidth, viewheight);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// R_RefreshViewBorder
//
// Draws the border around the player view, if needed.
//
//==========================================================================
- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.
2018-03-26 21:16:27 +00:00
void DFrameBuffer::RefreshViewBorder ()
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (setblocks < 10)
{
- removed the border refresh counter. This was just a relic of DirectDraw as main backend and is no longer needed.
2018-04-02 22:50:40 +00:00
DrawViewBorder();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- moved the screen blending code out of the renderer. This is better be made part of the 2D interface. That would have been done long ago if it hadn't been for the totally incompatible way this was handled by the purely paletted software renderer. Now with that out of the way there is no point keeping this code this deeply embedded in the renderer.
2018-05-05 09:20:37 +00:00
//==========================================================================
//
// Draws a blend over the entire view
//
//==========================================================================
void DFrameBuffer::DrawBlend(sector_t * viewsector)
{
float blend[4] = { 0,0,0,0 };
PalEntry blendv = 0;
float extra_red;
float extra_green;
float extra_blue;
player_t *player = nullptr;
bool fullbright = false;
if (players[consoleplayer].camera != nullptr)
{
player = players[consoleplayer].camera->player;
- fix null pointer crash
2018-05-06 00:31:58 +00:00
if (player)
fullbright = (player->fixedcolormap != NOFIXEDCOLORMAP || player->extralight == INT_MIN || player->fixedlightlevel != -1);
- moved the screen blending code out of the renderer. This is better be made part of the 2D interface. That would have been done long ago if it hadn't been for the totally incompatible way this was handled by the purely paletted software renderer. Now with that out of the way there is no point keeping this code this deeply embedded in the renderer.
2018-05-05 09:20:37 +00:00
}
// don't draw sector based blends when any fullbright screen effect is active.
if (!fullbright)
{
if (!viewsector->e->XFloor.ffloors.Size())
{
if (viewsector->GetHeightSec())
{
auto s = viewsector->heightsec;
blendv = s->floorplane.PointOnSide(r_viewpoint.Pos) < 0 ? s->bottommap : s->ceilingplane.PointOnSide(r_viewpoint.Pos) < 0 ? s->topmap : s->midmap;
}
}
else
{
TArray<lightlist_t> & lightlist = viewsector->e->XFloor.lightlist;
for (unsigned int i = 0; i < lightlist.Size(); i++)
{
double lightbottom;
if (i < lightlist.Size() - 1)
lightbottom = lightlist[i + 1].plane.ZatPoint(r_viewpoint.Pos);
else
lightbottom = viewsector->floorplane.ZatPoint(r_viewpoint.Pos);
if (lightbottom < r_viewpoint.Pos.Z && (!lightlist[i].caster || !(lightlist[i].caster->flags&FF_FADEWALLS)))
{
// 3d floor 'fog' is rendered as a blending value
blendv = lightlist[i].blend;
// If this is the same as the sector's it doesn't apply!
if (blendv == viewsector->Colormap.FadeColor) blendv = 0;
// a little hack to make this work for Legacy maps.
if (blendv.a == 0 && blendv != 0) blendv.a = 128;
break;
}
}
}
if (blendv.a == 0 && V_IsTrueColor()) // The paletted software renderer uses the original colormap as this frame's palette, but in true color that isn't doable.
{
blendv = R_BlendForColormap(blendv);
}
if (blendv.a == 255)
{
extra_red = blendv.r / 255.0f;
extra_green = blendv.g / 255.0f;
extra_blue = blendv.b / 255.0f;
// If this is a multiplicative blend do it separately and add the additive ones on top of it.
// black multiplicative blends are ignored
if (extra_red || extra_green || extra_blue)
{
screen->Dim(blendv, 1, 0, 0, screen->GetWidth(), screen->GetHeight(), &LegacyRenderStyles[STYLE_Multiply]);
}
blendv = 0;
}
else if (blendv.a)
{
// [Nash] allow user to set blend intensity
int cnt = blendv.a;
cnt = (int)(cnt * underwater_fade_scalar);
V_AddBlend(blendv.r / 255.f, blendv.g / 255.f, blendv.b / 255.f, cnt / 255.0f, blend);
}
}
- refactoring of fixed colormap stuff to have it better organized and to reduce the number of uniforms in the main shader. This removes 3 uniforms, consisting of 9 floats. Those were merged into other values that never get used at the same time. It also moves the costly setup of the fixed colormap out of the render state into the 2D processing code. Since 3D forces use of render buffers now, it is no longer necessary to draw the entire scene with the colormap active, meaning it can be handled more efficiently.
2018-06-16 11:47:24 +00:00
else if (player && player->fixedlightlevel != -1 && player->fixedcolormap != NOFIXEDCOLORMAP)
{
// Draw fixedlightlevel effects as a 2D overlay. The hardware renderer just processes such a scene fullbright without any lighting.
auto torchtype = PClass::FindActor(NAME_PowerTorch);
auto litetype = PClass::FindActor(NAME_PowerLightAmp);
PalEntry color = 0xffffffff;
for (AInventory * in = player->mo->Inventory; in; in = in->Inventory)
{
// Need special handling for light amplifiers
if (in->IsKindOf(torchtype))
{
// The software renderer already bakes the torch flickering into its output, so this must be omitted here.
float r = vid_rendermode < 4? 1.f : (0.8f + (7 - player->fixedlightlevel) / 70.0f);
if (r > 1.0f) r = 1.0f;
int rr = (int)(r * 255);
int b = rr;
if (gl_enhanced_nightvision) b = b * 3 / 4;
color = PalEntry(255, rr, rr, b);
}
else if (in->IsKindOf(litetype))
{
if (gl_enhanced_nightvision)
{
color = PalEntry(255, 104, 255, 104);
}
}
}
if (color != 0xffffffff)
{
screen->Dim(color, 1, 0, 0, screen->GetWidth(), screen->GetHeight(), &LegacyRenderStyles[STYLE_Multiply]);
}
}
- moved the screen blending code out of the renderer. This is better be made part of the 2D interface. That would have been done long ago if it hadn't been for the totally incompatible way this was handled by the purely paletted software renderer. Now with that out of the way there is no point keeping this code this deeply embedded in the renderer.
2018-05-05 09:20:37 +00:00
if (player)
{
V_AddPlayerBlend(player, blend, 0.5, 175);
}
if (players[consoleplayer].camera != NULL)
{
// except for fadeto effects
player_t *player = (players[consoleplayer].camera->player != NULL) ? players[consoleplayer].camera->player : &players[consoleplayer];
V_AddBlend(player->BlendR, player->BlendG, player->BlendB, player->BlendA, blend);
}
screen->Dim(PalEntry(255, uint8_t(blend[0] * 255), uint8_t(blend[1] * 255), uint8_t(blend[2] * 255)), blend[3], 0, 0, screen->GetWidth(), screen->GetHeight());
}
Reference in a new issue Copy permalink