mirror of
https://github.com/ZDoom/gzdoom.git
synced 2024-11-27 22:33:17 +00:00
- moved VM thunks from p_sectors.cpp to a separate file and started adding direct native implementations.
For a few larger functions I took them out of sector_t and made them global functions to avoid creating more unnecessary stubs.
This commit is contained in:
Christoph Oelckers
parent
a501a22b28
commit
dc16c1d44e
6 changed files with 926 additions and 864 deletions
|
|
@ -1149,6 +1149,7 @@ set (PCH_SOURCES
|
|||
r_data/models/models_ue1.cpp
|
||||
r_data/models/models_obj.cpp
|
||||
scripting/symbols.cpp
|
||||
scripting/vmthunks.cpp
|
||||
scripting/types.cpp
|
||||
scripting/thingdef.cpp
|
||||
scripting/thingdef_data.cpp
|
||||
|
|
|
|||
|
|
@ -368,13 +368,13 @@ bool P_CreateCeiling(sector_t *sec, DCeiling::ECeiling type, line_t *line, int t
|
|||
break;
|
||||
|
||||
case DCeiling::ceilLowerByTexture:
|
||||
targheight = sec->ceilingplane.ZatPoint (spot) - sec->FindShortestUpperAround ();
|
||||
targheight = sec->ceilingplane.ZatPoint (spot) - FindShortestUpperAround (sec);
|
||||
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
|
||||
ceiling->m_Direction = -1;
|
||||
break;
|
||||
|
||||
case DCeiling::ceilRaiseByTexture:
|
||||
targheight = sec->ceilingplane.ZatPoint (spot) + sec->FindShortestUpperAround ();
|
||||
targheight = sec->ceilingplane.ZatPoint (spot) + FindShortestUpperAround (sec);
|
||||
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
|
||||
ceiling->m_Direction = 1;
|
||||
break;
|
||||
|
|
@ -420,8 +420,8 @@ bool P_CreateCeiling(sector_t *sec, DCeiling::ECeiling type, line_t *line, int t
|
|||
type == DCeiling::ceilRaiseToFloor ||
|
||||
/*type == ceilLowerToHighest ||*/
|
||||
type == DCeiling::ceilLowerToFloor) ?
|
||||
sec->FindModelFloorSector (targheight) :
|
||||
sec->FindModelCeilingSector (targheight);
|
||||
FindModelFloorSector(sec, targheight) :
|
||||
FindModelCeilingSector(sec, targheight);
|
||||
if (modelsec != NULL)
|
||||
{
|
||||
ceiling->m_Texture = modelsec->GetTexture(sector_t::ceiling);
|
||||
|
|
|
|||
|
|
@ -392,7 +392,7 @@ bool P_CreateFloor(sector_t *sec, DFloor::EFloor floortype, line_t *line,
|
|||
|
||||
case DFloor::floorLowerByTexture:
|
||||
floor->m_Direction = -1;
|
||||
newheight = sec->CenterFloor() - sec->FindShortestTextureAround();
|
||||
newheight = sec->CenterFloor() - FindShortestTextureAround(sec);
|
||||
floor->m_FloorDestDist = sec->floorplane.PointToDist(sec->centerspot, newheight);
|
||||
break;
|
||||
|
||||
|
|
@ -409,7 +409,7 @@ bool P_CreateFloor(sector_t *sec, DFloor::EFloor floortype, line_t *line,
|
|||
// since the code is identical to what was here. (Oddly
|
||||
// enough, BOOM preserved the code here even though it
|
||||
// also had this function.)
|
||||
newheight = sec->CenterFloor() + sec->FindShortestTextureAround();
|
||||
newheight = sec->CenterFloor() + FindShortestTextureAround(sec);
|
||||
floor->m_FloorDestDist = sec->floorplane.PointToDist(sec->centerspot, newheight);
|
||||
break;
|
||||
|
||||
|
|
@ -440,7 +440,7 @@ bool P_CreateFloor(sector_t *sec, DFloor::EFloor floortype, line_t *line,
|
|||
|
||||
//jff 5/23/98 use model subroutine to unify fixes and handling
|
||||
sector_t *modelsec;
|
||||
modelsec = sec->FindModelFloorSector(newheight);
|
||||
modelsec = FindModelFloorSector(sec, newheight);
|
||||
if (modelsec != NULL)
|
||||
{
|
||||
floor->m_Texture = modelsec->GetTexture(sector_t::floor);
|
||||
|
|
@ -485,8 +485,8 @@ bool P_CreateFloor(sector_t *sec, DFloor::EFloor floortype, line_t *line,
|
|||
floortype == DFloor::floorLowerToLowestCeiling ||
|
||||
floortype == DFloor::floorRaiseToCeiling ||
|
||||
floortype == DFloor::floorLowerToCeiling) ?
|
||||
sec->FindModelCeilingSector(-floor->m_FloorDestDist) :
|
||||
sec->FindModelFloorSector(-floor->m_FloorDestDist);
|
||||
FindModelCeilingSector(sec, -floor->m_FloorDestDist) :
|
||||
FindModelFloorSector(sec, -floor->m_FloorDestDist);
|
||||
|
||||
if (modelsec != NULL)
|
||||
{
|
||||
|
|
@ -1126,7 +1126,7 @@ bool EV_DoChange (line_t *line, EChange changetype, int tag)
|
|||
}
|
||||
break;
|
||||
case numChangeOnly:
|
||||
secm = sec->FindModelFloorSector (sec->CenterFloor());
|
||||
secm = FindModelFloorSector(sec, sec->CenterFloor());
|
||||
if (secm)
|
||||
{ // if no model, no change
|
||||
sec->SetTexture(sector_t::floor, secm->GetTexture(sector_t::floor));
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
10
src/r_defs.h
10
src/r_defs.h
|
|
@ -630,10 +630,6 @@ public:
|
|||
double FindHighestCeilingSurrounding(vertex_t **v) const; // jff 2/04/98
|
||||
double FindNextLowestCeiling(vertex_t **v) const; // jff 2/04/98
|
||||
double FindNextHighestCeiling(vertex_t **v) const; // jff 2/04/98
|
||||
double FindShortestTextureAround() const; // jff 2/04/98
|
||||
double FindShortestUpperAround() const; // jff 2/04/98
|
||||
sector_t *FindModelFloorSector(double floordestheight) const; // jff 2/04/98
|
||||
sector_t *FindModelCeilingSector(double floordestheight) const; // jff 2/04/98
|
||||
int FindMinSurroundingLight (int max) const;
|
||||
sector_t *NextSpecialSector (int type, sector_t *prev) const; // [RH]
|
||||
double FindLowestCeilingPoint(vertex_t **v) const;
|
||||
|
|
@ -1603,4 +1599,10 @@ inline void FColormap::CopyFrom3DLight(lightlist_t *light)
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
double FindShortestTextureAround(sector_t *sector); // jff 2/04/98
|
||||
double FindShortestUpperAround(sector_t *sector); // jff 2/04/98
|
||||
sector_t *FindModelFloorSector(sector_t *sec, double floordestheight); // jff 2/04/98
|
||||
sector_t *FindModelCeilingSector(sector_t *sec, double floordestheight); // jff 2/04/98
|
||||
|
||||
#endif
|
||||
|
|
|
|||
898
src/scripting/vmthunks.cpp
Normal file
898
src/scripting/vmthunks.cpp
Normal file
|
|
@ -0,0 +1,898 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright 2016-2018 Christoph Oelckers
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see http://www.gnu.org/licenses/
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// VM thunks for simple functions.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "vm.h"
|
||||
#include "r_defs.h"
|
||||
#include "g_levellocals.h"
|
||||
#include "s_sound.h"
|
||||
#include "p_local.h"
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, FindShortestTextureAround, FindShortestTextureAround)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
ACTION_RETURN_FLOAT(FindShortestTextureAround(self));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, FindShortestUpperAround, FindShortestUpperAround)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
ACTION_RETURN_FLOAT(FindShortestUpperAround(self));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, FindModelFloorSector, FindModelFloorSector)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_FLOAT(fdh);
|
||||
auto h = FindModelFloorSector(self, fdh);
|
||||
ACTION_RETURN_POINTER(h);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, FindModelCeilingSector, FindModelCeilingSector)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_FLOAT(fdh);
|
||||
auto h = FindModelCeilingSector(self, fdh);
|
||||
ACTION_RETURN_POINTER(h);
|
||||
}
|
||||
|
||||
// Note: Do not use struct types like PalEntry as argument types here! We never know what the compilers will do with them.
|
||||
static void SetColor(sector_t *self, int color, int desat)
|
||||
{
|
||||
self->Colormap.LightColor.SetRGB(color);
|
||||
self->Colormap.Desaturation = desat;
|
||||
P_RecalculateAttachedLights(self);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, SetColor, SetColor)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_COLOR(color);
|
||||
PARAM_INT(desat);
|
||||
SetColor(self, color, desat);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void SetFade(sector_t *self, int fade)
|
||||
{
|
||||
self->Colormap.FadeColor.SetRGB(fade);
|
||||
P_RecalculateAttachedLights(self);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, SetFade, SetFade)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_COLOR(fade);
|
||||
SetFade(self, fade);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void SetSpecialColor(sector_t *self, int num, int _color)
|
||||
{
|
||||
if (num >= 0 && num < 5)
|
||||
{
|
||||
PalEntry color = _color;
|
||||
color.a = 255;
|
||||
self->SetSpecialColor(num, color);
|
||||
}
|
||||
}
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, SetSpecialColor, SetSpecialColor)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(num);
|
||||
PARAM_COLOR(color);
|
||||
SetSpecialColor(self, num, color);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void SetFogDensity(sector_t *self, int dens)
|
||||
{
|
||||
self->Colormap.FogDensity = dens;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, SetFogDensity, SetFogDensity)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(dens);
|
||||
self->Colormap.FogDensity = dens;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int PlaneMoving(sector_t *self, int pos)
|
||||
{
|
||||
return self->PlaneMoving(pos);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, PlaneMoving)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_BOOL(self->PlaneMoving(pos));
|
||||
}
|
||||
|
||||
static int GetFloorLight(sector_t *self)
|
||||
{
|
||||
return self->GetFloorLight();
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, GetFloorLight, GetFloorLight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
ACTION_RETURN_INT(self->GetFloorLight());
|
||||
}
|
||||
|
||||
static int GetCeilingLight(sector_t *self)
|
||||
{
|
||||
return self->GetCeilingLight();
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, GetCeilingLight, GetCeilingLight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
ACTION_RETURN_INT(self->GetCeilingLight());
|
||||
}
|
||||
|
||||
static sector_t *GetHeightSec(sector_t *self)
|
||||
{
|
||||
return self->GetHeightSec();
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, GetHeightSec, GetHeightSec)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
ACTION_RETURN_POINTER(self->GetHeightSec());
|
||||
}
|
||||
|
||||
static void GetSpecial(sector_t *self, secspecial_t *spec)
|
||||
{
|
||||
self->GetSpecial(spec);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION_NATIVE(_Sector, GetSpecial, GetSpecial)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_POINTER(spec, secspecial_t);
|
||||
self->GetSpecial(spec);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetSpecial)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_POINTER(spec, secspecial_t);
|
||||
self->SetSpecial(spec);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, TransferSpecial)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_POINTER(spec, sector_t);
|
||||
self->TransferSpecial(spec);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetTerrain)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_INT(self->GetTerrain(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, CheckPortalPlane)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(plane);
|
||||
self->CheckPortalPlane(plane);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, RemoveForceField)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
self->RemoveForceField();
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, AdjustFloorClip)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
self->AdjustFloorClip();
|
||||
return 0;
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
//
|
||||
//
|
||||
//===========================================================================
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, PointInSector)
|
||||
{
|
||||
PARAM_PROLOGUE;
|
||||
PARAM_FLOAT(x);
|
||||
PARAM_FLOAT(y);
|
||||
ACTION_RETURN_POINTER(P_PointInSector(x, y));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetXOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
self->SetXOffset(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, AddXOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
self->AddXOffset(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetXOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_FLOAT(self->GetXOffset(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetYOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
self->SetXOffset(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, AddYOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
self->AddXOffset(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetYOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_BOOL(addbase);
|
||||
ACTION_RETURN_FLOAT(self->GetYOffset(pos, addbase));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetXScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
self->SetXScale(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetXScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_FLOAT(self->GetXScale(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetYScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
self->SetYScale(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetYScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_FLOAT(self->GetYScale(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetAngle)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_ANGLE(o);
|
||||
self->SetAngle(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetAngle)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_BOOL(addbase);
|
||||
ACTION_RETURN_FLOAT(self->GetAngle(pos, addbase).Degrees);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetBase)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
PARAM_ANGLE(a);
|
||||
self->SetBase(pos, o, a);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetAlpha)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
self->SetAlpha(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetAlpha)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_FLOAT(self->GetAlpha(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetFlags)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_INT(self->GetFlags(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetVisFlags)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_INT(self->GetVisFlags(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, ChangeFlags)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_INT(a);
|
||||
PARAM_INT(o);
|
||||
self->ChangeFlags(pos, a, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetPlaneLight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_INT(o);
|
||||
self->SetPlaneLight(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetPlaneLight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_INT(self->GetPlaneLight(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetTexture)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_INT(o);
|
||||
PARAM_BOOL(adj);
|
||||
self->SetTexture(pos, FSetTextureID(o), adj);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetTexture)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_INT(self->GetTexture(pos).GetIndex());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetPlaneTexZ)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
PARAM_BOOL(dirty);
|
||||
self->SetPlaneTexZ(pos, o, true); // not setting 'dirty' here is a guaranteed cause for problems.
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetPlaneTexZ)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_FLOAT(self->GetPlaneTexZ(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetLightLevel)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(o);
|
||||
self->SetLightLevel(o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, ChangeLightLevel)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(o);
|
||||
self->ChangeLightLevel(o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetLightLevel)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
ACTION_RETURN_INT(self->GetLightLevel());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, PortalBlocksView)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_BOOL(self->PortalBlocksView(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, PortalBlocksSight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_BOOL(self->PortalBlocksSight(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, PortalBlocksMovement)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_BOOL(self->PortalBlocksMovement(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, PortalBlocksSound)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_BOOL(self->PortalBlocksSound(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, PortalIsLinked)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_BOOL(self->PortalIsLinked(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, ClearPortal)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
self->ClearPortal(pos);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetPortalPlaneZ)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_FLOAT(self->GetPortalPlaneZ(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetPortalDisplacement)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_VEC2(self->GetPortalDisplacement(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetPortalType)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_INT(self->GetPortalType(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetOppositePortalGroup)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_INT(self->GetOppositePortalGroup(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, CenterFloor)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
ACTION_RETURN_FLOAT(self->CenterFloor());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, CenterCeiling)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
ACTION_RETURN_FLOAT(self->CenterCeiling());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, Index)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
unsigned ndx = self->Index();
|
||||
if (ndx >= level.sectors.Size())
|
||||
{
|
||||
// This qualifies as an array out of bounds exception. Normally it can only happen when a sector copy is concerned which scripts should not be able to create.
|
||||
ThrowAbortException(X_ARRAY_OUT_OF_BOUNDS, "Accessed invalid sector");
|
||||
}
|
||||
ACTION_RETURN_INT(ndx);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetEnvironmentID)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(envnum);
|
||||
level.Zones[self->ZoneNumber].Environment = S_FindEnvironment(envnum);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetEnvironment)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_STRING(env);
|
||||
level.Zones[self->ZoneNumber].Environment = S_FindEnvironment(env);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetGlowHeight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_FLOAT(self->GetGlowHeight(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, GetGlowColor)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
ACTION_RETURN_INT(self->GetGlowColor(pos));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetGlowHeight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_FLOAT(o);
|
||||
self->SetGlowHeight(pos, float(o));
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Sector, SetGlowColor)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
|
||||
PARAM_INT(pos);
|
||||
PARAM_COLOR(o);
|
||||
self->SetGlowColor(pos, o);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
// line_t exports
|
||||
//
|
||||
//===========================================================================
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Line, isLinePortal)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(line_t);
|
||||
ACTION_RETURN_BOOL(self->isLinePortal());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Line, isVisualPortal)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(line_t);
|
||||
ACTION_RETURN_BOOL(self->isVisualPortal());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Line, getPortalDestination)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(line_t);
|
||||
ACTION_RETURN_POINTER(self->getPortalDestination());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Line, getPortalAlignment)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(line_t);
|
||||
ACTION_RETURN_INT(self->getPortalAlignment());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Line, Index)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(line_t);
|
||||
unsigned ndx = self->Index();
|
||||
if (ndx >= level.lines.Size())
|
||||
{
|
||||
ThrowAbortException(X_ARRAY_OUT_OF_BOUNDS, "Accessed invalid line");
|
||||
}
|
||||
ACTION_RETURN_INT(ndx);
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
//
|
||||
//
|
||||
//===========================================================================
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, GetTexture)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
ACTION_RETURN_INT(self->GetTexture(which).GetIndex());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, SetTexture)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_INT(tex);
|
||||
self->SetTexture(which, FSetTextureID(tex));
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, SetTextureXOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_FLOAT(ofs);
|
||||
self->SetTextureXOffset(which, ofs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, AddTextureXOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_FLOAT(ofs);
|
||||
self->AddTextureXOffset(which, ofs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, GetTextureXOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
ACTION_RETURN_FLOAT(self->GetTextureXOffset(which));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, SetTextureYOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_FLOAT(ofs);
|
||||
self->SetTextureYOffset(which, ofs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, AddTextureYOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_FLOAT(ofs);
|
||||
self->AddTextureYOffset(which, ofs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, GetTextureYOffset)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
ACTION_RETURN_FLOAT(self->GetTextureYOffset(which));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, SetTextureXScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_FLOAT(ofs);
|
||||
self->SetTextureXScale(which, ofs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, MultiplyTextureXScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_FLOAT(ofs);
|
||||
self->MultiplyTextureXScale(which, ofs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, GetTextureXScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
ACTION_RETURN_FLOAT(self->GetTextureXScale(which));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, SetTextureYScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_FLOAT(ofs);
|
||||
self->SetTextureYScale(which, ofs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, MultiplyTextureYScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
PARAM_FLOAT(ofs);
|
||||
self->MultiplyTextureYScale(which, ofs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, GetTextureYScale)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(which);
|
||||
ACTION_RETURN_FLOAT(self->GetTextureYScale(which));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, V1)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
ACTION_RETURN_POINTER(self->V1());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, V2)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
ACTION_RETURN_POINTER(self->V2());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, Index)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
ACTION_RETURN_INT(self->Index());
|
||||
}
|
||||
|
||||
//=====================================================================================
|
||||
//
|
||||
//
|
||||
//=====================================================================================
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Side, SetSpecialColor)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(side_t);
|
||||
PARAM_INT(tier);
|
||||
PARAM_INT(position);
|
||||
PARAM_COLOR(color);
|
||||
if (tier >= 0 && tier < 3 && position >= 0 && position < 2)
|
||||
{
|
||||
color.a = 255;
|
||||
self->SetSpecialColor(tier, position, color);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Vertex, Index)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(vertex_t);
|
||||
ACTION_RETURN_INT(self->Index());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_TexMan, ReplaceTextures)
|
||||
{
|
||||
PARAM_PROLOGUE;
|
||||
PARAM_STRING(from);
|
||||
PARAM_STRING(to);
|
||||
PARAM_INT(flags);
|
||||
P_ReplaceTextures(from, to, flags);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, isSlope)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
ACTION_RETURN_BOOL(!self->normal.XY().isZero());
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, PointOnSide)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
PARAM_FLOAT(x);
|
||||
PARAM_FLOAT(y);
|
||||
PARAM_FLOAT(z);
|
||||
ACTION_RETURN_INT(self->PointOnSide(DVector3(x, y, z)));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, ZatPoint)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
PARAM_FLOAT(x);
|
||||
PARAM_FLOAT(y);
|
||||
ACTION_RETURN_FLOAT(self->ZatPoint(x, y));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, ZatPointDist)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
PARAM_FLOAT(x);
|
||||
PARAM_FLOAT(y);
|
||||
PARAM_FLOAT(d);
|
||||
ACTION_RETURN_FLOAT((d + self->normal.X*x + self->normal.Y*y) * self->negiC);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, isEqual)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
PARAM_POINTER(other, secplane_t);
|
||||
ACTION_RETURN_BOOL(*self == *other);
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, ChangeHeight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
PARAM_FLOAT(hdiff);
|
||||
self->ChangeHeight(hdiff);
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, GetChangedHeight)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
PARAM_FLOAT(hdiff);
|
||||
ACTION_RETURN_FLOAT(self->GetChangedHeight(hdiff));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, HeightDiff)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
PARAM_FLOAT(oldd);
|
||||
PARAM_FLOAT(newd);
|
||||
if (newd != 1e37)
|
||||
{
|
||||
ACTION_RETURN_FLOAT(self->HeightDiff(oldd));
|
||||
}
|
||||
else
|
||||
{
|
||||
PARAM_FLOAT(newd);
|
||||
ACTION_RETURN_FLOAT(self->HeightDiff(oldd, newd));
|
||||
}
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Secplane, PointToDist)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(secplane_t);
|
||||
PARAM_FLOAT(x);
|
||||
PARAM_FLOAT(y);
|
||||
PARAM_FLOAT(z);
|
||||
ACTION_RETURN_FLOAT(self->PointToDist(DVector2(x, y), z));
|
||||
}
|
||||
|
||||
Loading…
Reference in a new issue