#region ================== Copyright (c) 2007 Pascal vd Heiden
/*
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
* This program is released under GNU General Public License
*
* 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.
*
*/
#endregion
#region ================== Namespaces
using System;
using System.Collections.Generic;
using CodeImp.DoomBuilder.Config;
using CodeImp.DoomBuilder.Data;
using CodeImp.DoomBuilder.Geometry;
using CodeImp.DoomBuilder.GZBuilder.Data; //mxd
using CodeImp.DoomBuilder.Map;
using CodeImp.DoomBuilder.Rendering;
using Plane = CodeImp.DoomBuilder.Geometry.Plane;
using CodeImp.DoomBuilder.GZBuilder;
using CodeImp.DoomBuilder.GZBuilder.MD3;
#endregion
namespace CodeImp.DoomBuilder.VisualModes
{
public abstract class VisualThing : IVisualPickable, IRenderResource, IDisposable
{
#region ================== Constants
protected const int FIXED_RADIUS = 8; //mxd. Used to render things with zero width and radius
private const float DYNLIGHT_INTENSITY_SCALER = 255.0f;
private const float SUBLIGHT_INTENSITY_SCALER = 255.0f * 1.5f; // Scaler for subtractive dynamic lights
#endregion
#region ================== Variables
// Thing
private readonly Thing thing;
//mxd. Info
protected ThingTypeInfo info;
// Textures
protected ImageData[] textures;
// Geometry
private WorldVertex[][] vertices;
private VertexBuffer[] geobuffers;
private VertexBuffer cagebuffer; //mxd
private int cagelength; //mxd
private bool updategeo;
private bool updatecage; //mxd
private int[] triangles;
private int spriteframe; //mxd
// Rendering
private RenderPass renderpass;
private Matrix position;
private int cameradistance;
private Color4 cagecolor;
protected bool sizeless; //mxd. Used to render visual things with 0 width and height
protected float fogfactor; //mxd
// Selected?
protected bool selected;
// Disposing
private bool isdisposed;
//mxd
protected float thingheight;
//mxd. light properties
private GZGeneral.LightData lightType;
private Color4 lightColor;
private float lightRadius; //current radius. used in light animation
private float lightSpotRadius1;
private float lightSpotRadius2;
private float lightPrimaryRadius;
private float lightSecondaryRadius;
private Vector3f position_v3;
private float lightDelta; //used in light animation
private Vector3D[] boundingBox;
//gldefs light
private Vector3f lightOffset;
private int lightInterval;
private bool isGldefsLight;
// [ZZ]
protected PixelColor stencilColor;
#endregion
#region ================== Properties
internal VertexBuffer GeometryBuffer { get {
if (geobuffers != null)
{
return geobuffers[spriteframe];
}
else
{
return null;
}
}
}
internal VertexBuffer CageBuffer { get { return cagebuffer; } } //mxd
internal int CageLength { get { return cagelength; } } //mxd
internal bool NeedsUpdateGeo { get { return updategeo; } }
internal int Triangles { get { return triangles[spriteframe]; } }
internal Matrix Position { get { return position; } }
internal Color4 CageColor { get { return cagecolor; } }
public ThingTypeInfo Info { get { return info; } } //mxd
//mxd
internal int VertexColor { get { return vertices.Length > 0 && vertices[0].Length > 0 ? vertices[0][0].c : 0; } }
public int CameraDistance { get { return cameradistance; } }
public float FogFactor { get { return fogfactor; } }
public Vector3f Center
{
get
{
if (isGldefsLight) return position_v3 + lightOffset;
else if (Thing.DynamicLightType != null) return position_v3; // fixes GZDoomBuilder-Bugfix#137
return new Vector3f(position_v3.X, position_v3.Y, position_v3.Z + thingheight / 2f);
}
}
public Vector3D CenterV3D { get { return RenderDevice.V3D(Center); } }
public float LocalCenterZ { get { return thingheight / 2f; } } //mxd
public Vector3f PositionV3 { get { return position_v3; } }
public Vector3D[] BoundingBox { get { return boundingBox; } }
//mxd. light properties
public GZGeneral.LightData LightType { get { return lightType; } }
public float LightRadius { get { return lightRadius; } }
public float LightSpotRadius1 { get { return lightSpotRadius1; } }
public float LightSpotRadius2 { get { return lightSpotRadius2; } }
public Color4 LightColor { get { return lightColor; } }
// [ZZ]
public PixelColor StencilColor { get { return stencilColor; } }
// [ZZ] this is used for spotlights
public Vector3f VectorLookAt
{
get
{
// this esoteric value (1.5708) is 90 degrees but in radians
return new Vector3f((float)(Math.Cos(Thing.Angle+1.5708) * Math.Cos(Angle2D.DegToRad(Thing.Pitch))), (float)(Math.Sin(Thing.Angle+1.5708) * Math.Cos(Angle2D.DegToRad(Thing.Pitch))), (float)Math.Sin(Angle2D.DegToRad(Thing.Pitch)));
}
}
///
/// Returns the Thing that this VisualThing is created for.
///
public Thing Thing { get { return thing; } }
///
/// Render pass in which this geometry must be rendered. Default is Mask.
///
public RenderPass RenderPass { get { return renderpass; } set { renderpass = value; } }
///
/// Image to use as texture on the geometry.
///
public ImageData Texture { get { return textures[spriteframe]; } }
///
/// Disposed or not?
///
public bool IsDisposed { get { return isdisposed; } }
///
/// Selected or not? This is only used by the core to determine what color to draw it with.
///
public bool Selected { get { return selected; } set { selected = value; } }
#endregion
#region ================== Constructor / Destructor
// Constructor
protected VisualThing(Thing t)
{
// Initialize
this.thing = t;
this.renderpass = RenderPass.Mask;
this.position = Matrix.Identity;
//mxd
lightType = null;
lightPrimaryRadius = -1;
lightSecondaryRadius = -1;
lightInterval = -1;
lightColor = new Color4();
boundingBox = new Vector3D[9];
// Register as resource
General.Map.Graphics.RegisterResource(this);
}
// Disposer
public virtual void Dispose()
{
// Not already disposed?
if(!isdisposed)
{
// Clean up
if(geobuffers != null) //mxd
{
foreach(VertexBuffer buffer in geobuffers) buffer.Dispose();
geobuffers = null;
}
if(cagebuffer != null) cagebuffer.Dispose(); //mxd
cagebuffer = null; //mxd
// Unregister resource
General.Map.Graphics.UnregisterResource(this);
// Done
isdisposed = true;
}
}
#endregion
#region ================== Methods
//mxd
internal void CalculateCameraDistance(Vector3D campos)
{
cameradistance = (int)((CenterV3D - campos).GetLengthSq());
}
// This is called before a device is reset (when resized or display adapter was changed)
public void UnloadResource()
{
// Trash geometry buffers
if(geobuffers != null) //mxd
{
foreach(VertexBuffer buffer in geobuffers) buffer.Dispose();
geobuffers = null;
}
if(cagebuffer != null) cagebuffer.Dispose(); //mxd
cagebuffer = null; //mxd
updategeo = true;
updatecage = true; //mxd
}
// This is called resets when the device is reset
// (when resized or display adapter was changed)
public void ReloadResource()
{
// Make new geometry
//Update();
}
///
/// Sets the color of the cage around the thing geometry and rebuilds the thing cage.
///
protected void SetCageColor(PixelColor color)
{
cagecolor = color.ToColorValue();
updatecage = true;
}
///
/// This sets the position to use for the thing geometry.
///
public void SetPosition(Vector3D pos)
{
position_v3 = RenderDevice.V3(pos); //mxd
position = Matrix.Translation(position_v3);
updategeo = true;
updatecage = true; //mxd
//mxd. update bounding box?
if (lightType != null && lightRadius > thing.Size)
{
UpdateBoundingBox(lightRadius, lightRadius * 2);
}
}
// This sets the vertices for the thing sprite
protected void SetVertices(WorldVertex[][] verts, Vector2D[] offsets/*, Plane floor, Plane ceiling*/)
{
// Copy vertices
vertices = new WorldVertex[verts.Length][];
triangles = new int[verts.Length];
//mxd
for(int i = 0; i < verts.Length; i++)
{
vertices[i] = new WorldVertex[verts[i].Length];
verts[i].CopyTo(vertices[i], 0);
triangles[i] = vertices[i].Length / 3;
}
updategeo = true;
//mxd. Do some special GZDoom rendering shenanigans...
for(int c = 0; c < vertices.Length; c++)
{
if(triangles[c] < 2) continue;
Matrix transform, rotation;
double centerx, centerz;
// ROLLCENTER flag support
if(info.RollSprite && info.RollCenter && thing.Roll != 0)
{
// Rotate around sprite center
centerx = offsets[c].x;
centerz = vertices[c][1].z * 0.5f - offsets[c].y;
}
else
{
// Sprite center is already where it needs to be
centerx = 0f;
centerz = 0f;
}
switch(thing.RenderMode)
{
// Don't do anything
case ThingRenderMode.MODEL: break;
case ThingRenderMode.VOXEL: break;
// Actor becomes a flat sprite which can be tilted with the use of the Pitch actor property.
case ThingRenderMode.FLATSPRITE:
transform = Matrix.Scaling((float)thing.ScaleX, (float)thing.ScaleX, (float)thing.ScaleY);
// Apply roll?
if(thing.Roll != 0)
{
if(info.RollCenter)
{
rotation = Matrix.RotationY((float)-thing.RollRad);
transform *= Matrix.Translation((float)-centerx, (float)-centerx, (float)-centerz) * rotation * Matrix.Translation((float)centerx, (float)centerx, (float)centerz);
}
else
{
// Sprite center is already where it needs to be
transform *= Matrix.RotationY((float)-thing.RollRad);
}
}
// Apply pitch
transform *= Matrix.RotationX((float)(thing.PitchRad + Angle2D.PIHALF));
// Apply angle
transform *= Matrix.RotationZ((float)thing.Angle);
// Apply transform
float zoffset = ((thing.Pitch == 0f && thing.Position.z == 0f) ? 0.1f : 0f); // Slight offset to avoid z-fighting...
for(int i = 0; i < vertices[c].Length; i++)
{
Vector4f transformed = Vector3f.Transform(new Vector3f(vertices[c][i].x, vertices[c][i].y, vertices[c][i].z), transform);
vertices[c][i].x = transformed.X;
vertices[c][i].y = transformed.Y;
vertices[c][i].z = transformed.Z + zoffset;
}
break;
// Similar to FLATSPRITE but is not affected by pitch.
case ThingRenderMode.WALLSPRITE:
transform = Matrix.Scaling((float)thing.ScaleX, (float)thing.ScaleX, (float)thing.ScaleY);
// Apply roll?
if(thing.Roll != 0)
{
rotation = Matrix.RotationY((float)-thing.RollRad) * Matrix.RotationZ((float)thing.Angle);
if(info.RollCenter)
transform *= Matrix.Translation((float)-centerx, (float)-centerx, (float)-centerz) * rotation * Matrix.Translation((float)centerx, (float)centerx, (float)centerz);
else
transform *= rotation; // Sprite center is already where it needs to be
}
else
{
transform *= Matrix.RotationZ((float)thing.Angle);
}
// Apply transform
for(int i = 0; i < vertices[c].Length; i++)
{
Vector4f transformed = Vector3f.Transform(new Vector3f(vertices[c][i].x, vertices[c][i].y, vertices[c][i].z), transform);
vertices[c][i].x = transformed.X;
vertices[c][i].y = transformed.Y;
vertices[c][i].z = transformed.Z;
}
break;
#region Some old GLOOME FLOOR_SPRITE/CEILING_SPRITE support code
/*case Thing.SpriteRenderMode.FLOOR_SPRITE:
Matrix floorrotation = Matrix.RotationZ(info.RollSprite ? Thing.RollRad : 0f)
* Matrix.RotationY(Thing.Angle)
* Matrix.RotationX(Angle2D.PIHALF);
m = Matrix.Translation(0f, 0f, -localcenterz) * floorrotation * Matrix.Translation(0f, 0f, localcenterz);
for(int i = 0; i < vertices[c].Length; i++)
{
Vector4 transformed = Vector3.Transform(new Vector3(vertices[c][i].x, vertices[c][i].y, vertices[c][i].z), m);
vertices[c][i].x = transformed.X;
vertices[c][i].y = transformed.Y;
vertices[c][i].z = transformed.Z;
}
// TODO: this won't work on things with AbsoluteZ flag
// TODO: +ROLLSPRITE implies +STICKTOPLANE?
if(info.StickToPlane || info.RollSprite)
{
// Calculate vertical offset
float floorz = floor.GetZ(Thing.Position);
float ceilz = ceiling.GetZ(Thing.Position);
if(!float.IsNaN(floorz) && !float.IsNaN(ceilz))
{
float voffset;
if(info.Hangs)
{
float thingz = ceilz - Thing.Position.z + Thing.Height;
voffset = 0.01f - floorz - General.Clamp(thingz, 0, ceilz - floorz);
}
else
{
voffset = 0.01f - floorz - General.Clamp(Thing.Position.z, 0, ceilz - floorz);
}
// Apply it
for(int i = 0; i < vertices[c].Length; i++)
vertices[c][i].z = floor.GetZ(vertices[c][i].x + Thing.Position.x, vertices[c][i].y + Thing.Position.y) + voffset;
}
}
break;
case Thing.SpriteRenderMode.CEILING_SPRITE:
Matrix ceilrotation = Matrix.RotationZ(info.RollSprite ? Thing.RollRad : 0f)
* Matrix.RotationY(Thing.Angle)
* Matrix.RotationX(Angle2D.PIHALF);
m = Matrix.Translation(0f, 0f, -localcenterz) * ceilrotation * Matrix.Translation(0f, 0f, localcenterz);
for(int i = 0; i < vertices[c].Length; i++)
{
Vector4 transformed = Vector3.Transform(new Vector3(vertices[c][i].x, vertices[c][i].y, vertices[c][i].z), m);
vertices[c][i].x = transformed.X;
vertices[c][i].y = transformed.Y;
vertices[c][i].z = transformed.Z;
}
// TODO: this won't work on things with AbsoluteZ flag
// TODO: +ROLLSPRITE implies +STICKTOPLANE?
if(info.StickToPlane || info.RollSprite)
{
// Calculate vertical offset
float floorz = floor.GetZ(Thing.Position);
float ceilz = ceiling.GetZ(Thing.Position);
if(!float.IsNaN(floorz) && !float.IsNaN(ceilz))
{
float voffset;
if(info.Hangs)
{
float thingz = ceilz - Math.Max(0, Thing.Position.z) - Thing.Height;
voffset = -0.01f - General.Clamp(thingz, 0, ceilz - floorz);
}
else
{
voffset = -0.01f - floorz - General.Clamp(Thing.Position.z, 0, ceilz - floorz);
}
// Apply it
for(int i = 0; i < vertices[c].Length; i++)
vertices[c][i].z = ceiling.GetZ(vertices[c][i].x + Thing.Position.x, vertices[c][i].y + Thing.Position.y) + voffset;
}
}
break;*/
#endregion
case ThingRenderMode.NORMAL:
transform = Matrix.Scaling((float)thing.ScaleX, (float)thing.ScaleX, (float)thing.ScaleY);
// Apply roll?
if(info.RollSprite && thing.Roll != 0)
{
rotation = Matrix.RotationY((float)-thing.RollRad);
if(info.RollCenter)
transform *= Matrix.Translation((float)-centerx, (float)-centerx, (float)-centerz) * rotation * Matrix.Translation((float)centerx, (float)centerx, (float)centerz);
else
transform *= rotation; // Sprite center is already where it needs to be
}
// Apply transform
for(int i = 0; i < vertices[c].Length; i++)
{
Vector4f transformed = Vector3f.Transform(new Vector3f(vertices[c][i].x, vertices[c][i].y, vertices[c][i].z), transform);
vertices[c][i].x = transformed.X;
vertices[c][i].y = transformed.Y;
vertices[c][i].z = transformed.Z;
}
break;
default: throw new NotImplementedException("Unknown ThingRenderMode");
}
}
}
// This updates the visual thing
public virtual void Update()
{
RenderDevice graphics = General.Map.Graphics;
// Do we need to update the geometry buffer?
if(updategeo)
{
//mxd. Trash geometry buffers
if(geobuffers != null)
foreach(VertexBuffer geobuffer in geobuffers) geobuffer.Dispose();
// Any vertics?
if(vertices.Length > 0)
{
geobuffers = new VertexBuffer[vertices.Length];
for(int i = 0; i < vertices.Length; i++)
{
// Make a new buffer
geobuffers[i] = new VertexBuffer();
// Fill the buffer
graphics.SetBufferData(geobuffers[i], vertices[i]);
}
}
//mxd. Check if thing is light
CheckLightState();
// Done
updategeo = false;
}
//mxd. Need to update thing cage?
if(updatecage)
{
// Trash cage buffer
if(cagebuffer != null) cagebuffer.Dispose();
cagebuffer = null;
// Make a new cage
List cageverts;
if(sizeless)
{
WorldVertex v0 = new WorldVertex(-thing.Size + position_v3.X, -thing.Size + position_v3.Y, position_v3.Z);
WorldVertex v1 = new WorldVertex(thing.Size + position_v3.X, thing.Size + position_v3.Y, position_v3.Z);
WorldVertex v2 = new WorldVertex(thing.Size + position_v3.X, -thing.Size + position_v3.Y, position_v3.Z);
WorldVertex v3 = new WorldVertex(-thing.Size + position_v3.X, thing.Size + position_v3.Y, position_v3.Z);
WorldVertex v4 = new WorldVertex(position_v3.X, position_v3.Y, thing.Size + position_v3.Z);
WorldVertex v5 = new WorldVertex(position_v3.X, position_v3.Y, -thing.Size + position_v3.Z);
cageverts = new List(new[] { v0, v1, v2, v3, v4, v5 });
}
else
{
float top = position_v3.Z + thing.Height;
float bottom = position_v3.Z;
WorldVertex v0 = new WorldVertex(-thing.Size + position_v3.X, -thing.Size + position_v3.Y, bottom);
WorldVertex v1 = new WorldVertex(-thing.Size + position_v3.X, thing.Size + position_v3.Y, bottom);
WorldVertex v2 = new WorldVertex(thing.Size + position_v3.X, thing.Size + position_v3.Y, bottom);
WorldVertex v3 = new WorldVertex(thing.Size + position_v3.X, -thing.Size + position_v3.Y, bottom);
WorldVertex v4 = new WorldVertex(-thing.Size + position_v3.X, -thing.Size + position_v3.Y, top);
WorldVertex v5 = new WorldVertex(-thing.Size + position_v3.X, thing.Size + position_v3.Y, top);
WorldVertex v6 = new WorldVertex(thing.Size + position_v3.X, thing.Size + position_v3.Y, top);
WorldVertex v7 = new WorldVertex(thing.Size + position_v3.X, -thing.Size + position_v3.Y, top);
cageverts = new List(new[] { v0, v1,
v1, v2,
v2, v3,
v3, v0,
v4, v5,
v5, v6,
v6, v7,
v7, v4,
v0, v4,
v1, v5,
v2, v6,
v3, v7 });
}
// Make new arrow
if(Thing.IsDirectional)
{
Matrix transform = Matrix.Scaling(thing.Size, thing.Size, thing.Size)
* (Matrix.RotationY((float)-Thing.RollRad) * Matrix.RotationX((float)-Thing.PitchRad) * Matrix.RotationZ((float)Thing.Angle))
* (sizeless ? position : position * Matrix.Translation(0.0f, 0.0f, thingheight / 2f));
WorldVertex a0 = new WorldVertex(Vector3D.Transform(0.0f, 0.0f, 0.0f, transform)); //start
WorldVertex a1 = new WorldVertex(Vector3D.Transform(0.0f, -1.5f, 0.0f, transform)); //end
WorldVertex a2 = new WorldVertex(Vector3D.Transform(0.2f, -1.1f, 0.2f, transform));
WorldVertex a3 = new WorldVertex(Vector3D.Transform(-0.2f, -1.1f, 0.2f, transform));
WorldVertex a4 = new WorldVertex(Vector3D.Transform(0.2f, -1.1f, -0.2f, transform));
WorldVertex a5 = new WorldVertex(Vector3D.Transform(-0.2f, -1.1f, -0.2f, transform));
cageverts.AddRange(new[] { a0, a1,
a1, a2,
a1, a3,
a1, a4,
a1, a5 });
}
// Create buffer
WorldVertex[] cv = cageverts.ToArray();
cagelength = cv.Length / 2;
cagebuffer = new VertexBuffer();
graphics.SetBufferData(cagebuffer, cv);
// Done
updatecage = false;
}
}
//mxd
protected void CheckLightState()
{
//mxd. Check if thing is light
if (thing.DynamicLightType != null)
{
isGldefsLight = false;
lightInterval = -1;
UpdateLight();
}
//check if we have light from GLDEFS
else if(General.Map.Data.GldefsEntries.ContainsKey(thing.Type))
{
isGldefsLight = true;
UpdateGldefsLight();
UpdateBoundingBox(lightRadius, lightRadius * 2);
}
else
{
UpdateBoundingBox((int)thing.Size, thingheight);
lightType = null;
lightRadius = -1;
lightSpotRadius1 = lightSpotRadius2 = -1;
lightPrimaryRadius = -1;
lightSecondaryRadius = -1;
lightInterval = -1;
isGldefsLight = false;
}
}
//mxd. Update light info
public void UpdateLight()
{
lightType = thing.DynamicLightType;
if (lightType == null)
return;
GZGeneral.LightData ld = lightType;
if (ld.LightDef != GZGeneral.LightDef.VAVOOM_GENERIC &&
ld.LightDef != GZGeneral.LightDef.VAVOOM_COLORED) //if it's gzdoom light
{
if (ld.LightType == GZGeneral.LightType.POINT)
{
if (ld.LightDef != GZGeneral.LightDef.POINT_SUBTRACTIVE) // normal, additive, attenuated
{
//lightColor.Alpha used in shader to perform some calculations based on light type
lightColor = new Color4(
thing.Args[0] / DYNLIGHT_INTENSITY_SCALER,
thing.Args[1] / DYNLIGHT_INTENSITY_SCALER,
thing.Args[2] / DYNLIGHT_INTENSITY_SCALER,
(float)ld.LightRenderStyle / 100.0f);
}
else // negative
{
lightColor = new Color4(
thing.Args[0] / SUBLIGHT_INTENSITY_SCALER,
thing.Args[1] / SUBLIGHT_INTENSITY_SCALER,
thing.Args[2] / SUBLIGHT_INTENSITY_SCALER,
(float)ld.LightRenderStyle / 100.0f);
}
}
else
{
int c1, c2, c3;
if (thing.Fields.ContainsKey("arg0str"))
{
PixelColor pc;
ZDoom.ZDTextParser.GetColorFromString(thing.Fields["arg0str"].Value.ToString(), out pc);
c1 = pc.r;
c2 = pc.g;
c3 = pc.b;
}
else
{
c1 = (thing.Args[0] & 0xFF0000) >> 16;
c2 = (thing.Args[0] & 0x00FF00) >> 8;
c3 = (thing.Args[0] & 0x0000FF);
}
if (ld.LightDef != GZGeneral.LightDef.SPOT_SUBTRACTIVE)
{
lightColor = new Color4(
c1 / DYNLIGHT_INTENSITY_SCALER,
c2 / DYNLIGHT_INTENSITY_SCALER,
c3 / DYNLIGHT_INTENSITY_SCALER,
(float)ld.LightRenderStyle / 100.0f);
}
else
{
lightColor = new Color4(
c1 / SUBLIGHT_INTENSITY_SCALER,
c2 / SUBLIGHT_INTENSITY_SCALER,
c3 / SUBLIGHT_INTENSITY_SCALER,
(float)ld.LightRenderStyle / 100.0f);
}
}
if(lightType.LightModifier == GZGeneral.LightModifier.SECTOR)
{
int scaler = 1;
if(thing.Sector != null) scaler = thing.Sector.Brightness / 4;
lightPrimaryRadius = (thing.Args[3] * scaler);
}
else
{
lightPrimaryRadius = (thing.Args[3] * 2); //works... that.. way in GZDoom
if (lightType.LightAnimated)
lightSecondaryRadius = (thing.Args[4] * 2);
}
if (lightType.LightType == GZGeneral.LightType.SPOT)
{
lightSpotRadius1 = (thing.Args[1]);
lightSpotRadius2 = (thing.Args[2]);
}
}
else //it's one of vavoom lights
{
if(lightType.LightDef == GZGeneral.LightDef.VAVOOM_COLORED)
{
lightColor = new Color4(
thing.Args[1] / DYNLIGHT_INTENSITY_SCALER,
thing.Args[2] / DYNLIGHT_INTENSITY_SCALER,
thing.Args[3] / DYNLIGHT_INTENSITY_SCALER,
(float)ld.LightRenderStyle / 100.0f);
}
else
{
lightColor = new Color4(0.5f, 0.5f, 0.5f, (float)ld.LightRenderStyle / 100.0f);
}
lightPrimaryRadius = (thing.Args[0] * 8);
}
UpdateLightRadius();
UpdateBoundingBox(lightRadius, lightRadius * 2);
}
//mxd
private void UpdateGldefsLight()
{
DynamicLightData light = General.Map.Data.GldefsEntries[thing.Type];
GZGeneral.LightData ld = light.Type;
//apply settings
lightColor = new Color4(light.Color.Red, light.Color.Green, light.Color.Blue, (float)ld.LightRenderStyle / 100.0f);
Vector2D o = new Vector2D(light.Offset.X, light.Offset.Y).GetRotated(thing.Angle - Angle2D.PIHALF);
lightOffset = new Vector3f((float)o.x, (float)o.y, light.Offset.Z);
lightType = light.Type;
if(ld.LightModifier == GZGeneral.LightModifier.SECTOR)
{
lightPrimaryRadius = light.Interval * thing.Sector.Brightness / 5.0f;
}
else
{
lightPrimaryRadius = light.PrimaryRadius;
lightSecondaryRadius = light.SecondaryRadius;
}
lightInterval = light.Interval;
UpdateLightRadius(lightInterval);
}
//mxd
public void UpdateLightRadius()
{
UpdateLightRadius( (lightInterval != -1 ? lightInterval : thing.AngleDoom) );
}
//mxd
private void UpdateLightRadius(int interval)
{
if(lightType == null) return;
if(General.Settings.GZDrawLightsMode == LightRenderMode.ALL || !lightType.LightAnimated)
{
lightRadius = lightPrimaryRadius;
return;
}
if(interval == 0)
{
lightRadius = 0;
return;
}
float rMin = Math.Min(lightPrimaryRadius, lightSecondaryRadius);
float rMax = Math.Max(lightPrimaryRadius, lightSecondaryRadius);
float diff = rMax - rMin;
switch(lightType.LightModifier)
{
case GZGeneral.LightModifier.PULSE:
lightDelta = ((float)Math.Sin(Clock.CurrentTime / (interval * 4.0f)) + 1.0f) / 2.0f; //just playing by the eye here... in [0.0 ... 1.0] interval
lightRadius = rMin + diff * lightDelta;
break;
case GZGeneral.LightModifier.FLICKER:
float fdelta = (float)Math.Sin(Clock.CurrentTime / 0.1f); //just playing by the eye here...
if(Math.Sign(fdelta) != Math.Sign(lightDelta))
{
lightDelta = fdelta;
lightRadius = (General.Random(0, 359) < interval ? rMax : rMin);
}
break;
case GZGeneral.LightModifier.FLICKERRANDOM:
float rdelta = (float)Math.Sin(Clock.CurrentTime / (interval * 9.0f)); //just playing by the eye here...
if(Math.Sign(rdelta) != Math.Sign(lightDelta))
{
lightRadius = rMin + (General.Random(0, (int) (diff * 10))) / 10.0f;
}
lightDelta = rdelta;
break;
}
}
//mxd. update bounding box
public void UpdateBoundingBox()
{
if(lightType != null && lightRadius > thing.Size)
UpdateBoundingBox(lightRadius, lightRadius * 2);
}
private void UpdateBoundingBox(float width, float height)
{
boundingBox = new Vector3D[9];
boundingBox[0] = CenterV3D;
if (Thing.RenderMode != ThingRenderMode.MODEL && Thing.RenderMode != ThingRenderMode.VOXEL)
{
float h2 = height / 2.0f;
boundingBox[1] = new Vector3D(position_v3.X - width, position_v3.Y - width, Center.Z - h2);
boundingBox[2] = new Vector3D(position_v3.X + width, position_v3.Y - width, Center.Z - h2);
boundingBox[3] = new Vector3D(position_v3.X - width, position_v3.Y + width, Center.Z - h2);
boundingBox[4] = new Vector3D(position_v3.X + width, position_v3.Y + width, Center.Z - h2);
boundingBox[5] = new Vector3D(position_v3.X - width, position_v3.Y - width, Center.Z + h2);
boundingBox[6] = new Vector3D(position_v3.X + width, position_v3.Y - width, Center.Z + h2);
boundingBox[7] = new Vector3D(position_v3.X - width, position_v3.Y + width, Center.Z + h2);
boundingBox[8] = new Vector3D(position_v3.X + width, position_v3.Y + width, Center.Z + h2);
}
else
{
GZModel model = General.Map?.Data?.ModeldefEntries[Thing.Type]?.Model;
if (model != null)
{
Vector3D offs = new Vector3D(position_v3.X, position_v3.Y, position_v3.Z);
boundingBox[5] = new Vector3D(model.BBox.MinX, model.BBox.MinY, model.BBox.MaxZ) + offs;
boundingBox[6] = new Vector3D(model.BBox.MaxX, model.BBox.MinY, model.BBox.MaxZ) + offs;
boundingBox[7] = new Vector3D(model.BBox.MinX, model.BBox.MaxY, model.BBox.MaxZ) + offs;
boundingBox[8] = new Vector3D(model.BBox.MaxX, model.BBox.MaxY, model.BBox.MaxZ) + offs;
boundingBox[1] = new Vector3D(model.BBox.MinX, model.BBox.MinY, model.BBox.MinZ) + offs;
boundingBox[2] = new Vector3D(model.BBox.MaxX, model.BBox.MinY, model.BBox.MinZ) + offs;
boundingBox[3] = new Vector3D(model.BBox.MinX, model.BBox.MaxY, model.BBox.MinZ) + offs;
boundingBox[4] = new Vector3D(model.BBox.MaxX, model.BBox.MaxY, model.BBox.MinZ) + offs;
boundingBox[0] = new Vector3D(0.5f * (model.BBox.MinX + model.BBox.MaxX),
0.5f * (model.BBox.MinY + model.BBox.MaxY),
0.5f * (model.BBox.MinZ + model.BBox.MaxZ)) + offs;
}
}
}
//mxd. This updates the sprite frame to be rendered
internal void UpdateSpriteFrame()
{
if(textures.Length != 8)
spriteframe = 0;
else
spriteframe = (General.ClampAngle((int)Angle2D.RadToDeg((General.Map.VisualCamera.Position - thing.Position).GetAngleXY()) - thing.AngleDoom + 292)) / 45; // Convert to [0..7] range; 292 == 270 + 45/2
}
///
/// This is called when the thing must be tested for line intersection. This should reject
/// as fast as possible to rule out all geometry that certainly does not touch the line.
///
public virtual bool PickFastReject(Vector3D from, Vector3D to, Vector3D dir)
{
return false;
}
///
/// This is called when the thing must be tested for line intersection. This should perform
/// accurate hit detection and set u_ray to the position on the ray where this hits the geometry.
///
public virtual bool PickAccurate(Vector3D from, Vector3D to, Vector3D dir, ref double u_ray)
{
return false;
}
#endregion
}
}