private void InitializeOutlineComponent()
{
Log.ActivateLog(LogMessageType.Info);
modelComponent = Entity.Get <ModelComponent>();
if (modelComponent == null)
{
Log.Error($"Model component not found on outline component.");
//throw new NullReferenceException($"Model component not found on outline component.");
}
else
{
configuredRenderGroup = modelComponent.RenderGroup;
}
// Model outline highlighting uses physics ray casting in BasicCameraController
physicsComponent = Entity.Get <PhysicsComponent>();
if (physicsComponent == null && AlwaysOutlined != true)
{
Log.Error($"Physics collider component not found on outline component.");
//throw new NullReferenceException($"Collider component not found outline component.");
}
if (AlwaysOutlined)
{
Enable();
}
}
public WaterFlowMapRenderObject(int size, RenderGroup rendergroup)
{
Size = System.Math.Max(1, size);
RenderGroup = rendergroup;
SkyTextureOffset = new Vector2(0.0f, 0.0f);
NormalTextureFlow = new TextureOffsets(0.4f, 0.5f, 10.5f, 0.5f);
DiffuseTextureFlow = new TextureOffsets(0.4f, 0.5f, 10.0f, 0.5f);
}
public FlatBufferBuilder BuildRender(int index, IEnumerable <IRenderCommand> renderCommands)
{
var builder = new FlatBufferBuilder(100);
var messages = new List <Offset <RenderMessage> >();
foreach (var command in renderCommands)
{
if (command is ClearScreenCommand)
{
//NOOP
break;
}
else if (command is Line2D3DCommand line2d3d)
{
Line2D3D(line2d3d, builder, messages);
}
else if (command is Line2DCommand line2d)
{
Line2D(line2d, builder, messages);
}
else if (command is Line3DCommand line3d)
{
Line3D(line3d, builder, messages);
}
else if (command is PolyLine2DCommand polyLine2d)
{
PolyLine2D(polyLine2d, builder, messages);
}
else if (command is PolyLine3DCommand polyLine3d)
{
PolyLine3D(polyLine3d, builder, messages);
}
else if (command is Rectangle2DCommand rectangle2d)
{
Rectangle2D(rectangle2d, builder, messages);
}
else if (command is Rectangle3DCommand rectangle3d)
{
Rectangle3D(rectangle3d, builder, messages);
}
else if (command is String2DCommand string2d)
{
String2D(string2d, builder, messages);
}
else if (command is String3DCommand string3d)
{
String3D(string3d, builder, messages);
}
}
var messagesVector = RenderGroup.CreateRenderMessagesVector(builder, messages.ToArray());
var renderGroup = RenderGroup.CreateRenderGroup(builder, messagesVector, index);
builder.Finish(renderGroup.Value);
return(builder);
}
/// <inheritdoc/>
public IVisual CreateVisual(IRenderContext context)
{
var container = new RenderGroup {
North = north, ResponseMessage = IsResponseMessage(), TextPlacement = ((ChoreographyMessageLabelStyle)style).TextPlacement
};
var delegateStyle = GetCurrentStyle(item, style);
container.Add(delegateStyle.Renderer.GetVisualCreator(item, delegateStyle).CreateVisual(context));
return(container);
}
public Gui(Game game, Gui holder, Rectangle bounds)
{
this.bounds = bounds;
init(game);
this.holder = holder;
if(holder == null){
this.renderGroup = new RenderGroup(game);
}
dirty = true;
}
private static void EndRenderingImpl(TreeManager tm, RenderManager.CameraInfo cameraInfo)
{
unsafe
{
if (Input.GetKeyDown(KeyCode.F5) && Event.current.control)
{
DebugOutputPanel.AddMessage(PluginManager.MessageType.Message, string.Format("TreeLimit: TreeCount={0}, TreeLimit={1}, CanPlaceMoreTrees={2}", tm.m_treeCount, LimitTreeManager.Helper.TreeLimit, tm.CheckLimits()));
Array32<TreeInstance> mTrees = tm.m_trees;
DebugOutputPanel.AddMessage(PluginManager.MessageType.Message, string.Format("TreeLimit: ArraySize={0}, ItemCount={1}, UnusedCount={2}", mTrees.m_size, mTrees.ItemCount(), mTrees.GetType().GetField("m_unusedCount", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(mTrees)));
}
FastList<RenderGroup> mRenderedGroups = Singleton<RenderManager>.instance.m_renderedGroups;
for (int i = 0; i < mRenderedGroups.m_size; i++)
{
RenderGroup mBuffer = mRenderedGroups.m_buffer[i];
if ((mBuffer.m_instanceMask & 1 << (tm.m_treeLayer & 31)) != 0)
{
int mX = mBuffer.m_x * 540 / 45;
int mZ = mBuffer.m_z * 540 / 45;
int num = (mBuffer.m_x + 1) * 540 / 45 - 1;
int mZ1 = (mBuffer.m_z + 1) * 540 / 45 - 1;
for (int j = mZ; j <= mZ1; j++)
{
for (int k = mX; k <= num; k++)
{
uint mTreeGrid = tm.m_treeGrid[j * 540 + k];
int num1 = 0;
while (mTreeGrid != 0)
{
tm.m_trees.m_buffer[mTreeGrid].RenderInstance(cameraInfo, mTreeGrid, mBuffer.m_instanceMask);
mTreeGrid = tm.m_trees.m_buffer[mTreeGrid].m_nextGridTree;
int num2 = num1 + 1;
num1 = num2;
if (num2 < LimitTreeManager.Helper.TreeLimit)
{
continue;
}
CODebugBase<LogChannel>.Error(LogChannel.Core, string.Concat("Invalid list detected!\n", Environment.StackTrace));
break;
}
}
}
}
}
int num3 = PrefabCollection<TreeInfo>.PrefabCount();
for (int l = 0; l < num3; l++)
{
TreeInfo prefab = PrefabCollection<TreeInfo>.GetPrefab((uint)l);
if (prefab != null && prefab.m_lodCount != 0)
{
TreeInstance.RenderLod(cameraInfo, prefab);
}
}
}
}
/// <summary>
/// Gets the light affecting a specific group.
/// </summary>
/// <param name="group">The group.</param>
/// <returns>LightComponentCollection.</returns>
public RenderLightCollection FindLightCollectionByGroup(RenderGroup group)
{
// If a mask is not zero, then we have a collection associated for this bit
int groupBaseIndex = (int)group * 2;
if (groupMasks[groupBaseIndex] != 0)
{
return(lightCollectionPool[groupMasks[groupBaseIndex + 1]]);
}
return(null);
}
private static UIComponent GetUIPage(RenderGroup renderGroup)
{
if (ScreenPages.TryGetValue(renderGroup, out var uiPage))
{
return(uiPage);
}
else
{
return(Create2DUIPage(renderGroup));
}
}
/// <summary>
/// Finishes the render packet and returns the complete packet.
/// </summary>
/// <returns>Returns the completed render packet.</returns>
protected RenderPacket DoFinishPacket()
{
var offsets = _renderMessageOffsets.ToArray();
var messagesOffset = RenderGroup.CreateRenderMessagesVector(Builder, offsets);
var renderGroupOffset = RenderGroup.CreateRenderGroup(Builder, messagesOffset, _index);
Builder.Finish(renderGroupOffset.Value);
var bytes = Builder.SizedByteArray();
ResetPacket();
return(new RenderPacket(bytes));
}
public override void Initialize()
{
RenderGroup group = new RenderGroup("PressStart");
parentManager.renderCore.renderGroups.Add(group);
background = new RenderImage(parentManager.renderCore, parentManager.game.Content.Load<Texture2D>("Graphic/PressStartScreen/BG"), group, 0,false, Vector2.Zero);
pressStart = new RenderImage(parentManager.renderCore, parentManager.game.Content.Load<Texture2D>("Graphic/PressStartScreen/Message"), group, 1, false, new Vector2(500, 500));
parentManager.renderCore.objects.Add(background);
parentManager.renderCore.objects.Add(pressStart);
parentManager.inputManager.registerHandler("PressStartHandler", new PressStartHandler(parentManager), true);
}
public Geometry(string meshName, int[] meshFaces, Vector3[] positions, Vector3[] normals, Vector2[][] uv,
Texture[] textures, string[] bones, BoneWeight[] boneBoneWeights, RenderGroup renderGroup)
{
Name = meshName;
Indices = meshFaces;
Positions = positions;
Normals = normals;
Uv = uv;
Textures = textures;
Bones = bones;
BoneWeights = boneBoneWeights;
RenderGroup = renderGroup;
}
public static void Postfix(ref RenderManager.CameraInfo cameraInfo)
{
ItemClass.Availability availability = ToolManager.instance.m_properties.m_mode;
FastList <RenderGroup> fastList = RenderManager.instance.m_renderedGroups;
int num1 = 1 << LayerMask.NameToLayer("Props") | 1 << RenderManager.instance.lightSystem.m_lightLayer;
for (int index1 = 0; index1 < fastList.m_size; ++index1)
{
RenderGroup renderGroup = fastList.m_buffer[index1];
if ((renderGroup.m_instanceMask & num1) != 0)
{
int minX = renderGroup.m_x * 270 / 45;
int minZ = renderGroup.m_z * 270 / 45;
int maxX = (renderGroup.m_x + 1) * 270 / 45 - 1;
int maxZ = (renderGroup.m_z + 1) * 270 / 45 - 1;
for (int index2 = minZ; index2 <= maxZ; ++index2)
{
for (int index3 = minX; index3 <= maxX; ++index3)
{
int gridKey = index2 * 270 + index3;
List <PropContainer> list = PropUnlimiterManager.instance.GetPropsInGrid(gridKey);
if (list != null)
{
foreach (PropContainer instance in list)
{
if (instance.extras.ContainsKey("accx") && instance.extras.ContainsKey("accy") && instance.extras.ContainsKey("accz"))
{
RenderProp(cameraInfo, instance);
}
else
{
instance.propInstance.RenderInstance(cameraInfo, 0, renderGroup.m_instanceMask);
}
}
}
}
}
}
}
for (int index = 0; index < PrefabCollection <PropInfo> .PrefabCount(); ++index)
{
PropInfo prefab = PrefabCollection <PropInfo> .GetPrefab((uint)index);
if (prefab != null && prefab.m_lodCount != 0)
{
PropInstance.RenderLod(cameraInfo, prefab);
}
}
}
/// <summary>
/// If this renderer has previously drawn anything on the screen, it will be erased.
/// This can be called at any time. It will not interrupt any packet construction
/// that may be in progress.
/// </summary>
public void EraseFromScreen()
{
var eraseBuilder = new FlatBufferBuilder(10);
var vectorOffset = RenderGroup.CreateRenderMessagesVector(eraseBuilder, new Offset <RenderMessage> [0]);
RenderGroup.StartRenderGroup(eraseBuilder);
RenderGroup.AddRenderMessages(eraseBuilder, vectorOffset);
RenderGroup.AddId(eraseBuilder, _index);
eraseBuilder.Finish(RenderGroup.EndRenderGroup(eraseBuilder).Value);
RenderPacket emptyPacket = new RenderPacket(eraseBuilder.SizedByteArray());
SendPacket(emptyPacket);
}
public static void ChangeRenderGroup(WindowImpl window, RenderGroup newRenderGroup)
{
if (window.Is2D)
{
RemoveWindow(window);
window.RenderGroup = newRenderGroup;
AddWindow(window);
}
else
{
var sprite = GetSprite(window);
window.RenderGroup = newRenderGroup;
sprite.RenderGroup = newRenderGroup;
}
}
public World(Game game, int width, int height, byte worldId)
{
this.game = game;
wallGrid = new byte[width, height];
this.width = width;
this.height = height;
this.worldId = worldId;
renderGroupXLow = new RenderGroup(game);
renderGroupXHigh = new RenderGroup(game);
renderGroupZLow = new RenderGroup(game);
renderGroupZHigh = new RenderGroup(game);
renderGroupTop = new RenderGroup(game);
renderGroupFloor = new RenderGroup(game);
}
public Entity CreateDebugEntity(PhysicsComponent component, RenderGroup renderGroup, bool alwaysAddOffset = false)
{
if (component?.ColliderShape == null)
{
return(null);
}
if (component.DebugEntity != null)
{
return(null);
}
var debugEntity = new Entity();
var skinnedElement = component as PhysicsSkinnedComponentBase;
if (skinnedElement != null && skinnedElement.BoneIndex != -1)
{
Vector3 scale, pos;
Quaternion rot;
skinnedElement.BoneWorldMatrixOut.Decompose(out scale, out rot, out pos);
debugEntity.Transform.Position = pos;
debugEntity.Transform.Rotation = rot;
}
else
{
Vector3 scale, pos;
Quaternion rot;
component.Entity.Transform.WorldMatrix.Decompose(out scale, out rot, out pos);
debugEntity.Transform.Position = pos;
debugEntity.Transform.Rotation = rot;
}
var shouldNotAddOffset = component is RigidbodyComponent || component is CharacterComponent;
//don't add offset for non bone dynamic and kinematic as it is added already in the updates
var colliderEntity = CreateChildEntity(component, component.ColliderShape, renderGroup, alwaysAddOffset || !shouldNotAddOffset);
if (colliderEntity != null)
{
debugEntity.AddChild(colliderEntity);
}
return(debugEntity);
}
public void AddDebugEntity(Scene scene, RenderGroup renderGroup = RenderGroup.Group0, bool alwaysAddOffset = false)
{
if (DebugEntity != null)
{
return;
}
var entity = Data?.PhysicsComponent?.DebugShapeRendering?.CreateDebugEntity(this, renderGroup, alwaysAddOffset);
DebugEntity = entity;
if (DebugEntity == null)
{
return;
}
scene.Entities.Add(entity);
}
private void QueueRenderMeshes()
{
lock (blocksToUpdate)
{
var renderGroup = new RenderGroup();
renderGroup.numBlocks = blocksToUpdate.Count;
renderGroups.Add(renderGroup);
if (blocksToUpdate.Count > 1)
{
var blocksToUpdate = new Block[this.blocksToUpdate.Count];
int i = 0;
foreach (var block in this.blocksToUpdate)
{
blocksToUpdate[i] = block;
i++;
}
this.blocksToUpdate.Clear();
System.Threading.ThreadPool.QueueUserWorkItem(o =>
{
foreach (var block in blocksToUpdate)
{
block.isDirty = false;
var voxelMesh = block.voxelObject.ComputeMesh(block);
renderGroup.completedBlocks.Add(new System.Tuple <Block, VoxelMesh>(block, voxelMesh));
}
});
}
else
{
foreach (var block in blocksToUpdate)
{
block.isDirty = false;
var voxelMesh = block.voxelObject.ComputeMesh(block);
renderGroup.completedBlocks.Add(new System.Tuple <Block, VoxelMesh>(block, voxelMesh));
}
blocksToUpdate.Clear();
}
}
}
public static RunLevel LoadLevel(string path,RenderingCore renderCore)
{
RunLevel level = new RunLevel();
FileLoader.activeFormat = FileFormat.NameFirst;
FileLoader.activeReader = new StreamReader(File.Open(path, FileMode.Open));
RenderGroup group = new RenderGroup("levelScenery");
level.name = (string)FileLoader.Load(string.Empty);
level.background = new RenderImage(renderCore, null, group, 0);
level.background.camAffected = true;
level.background.image = (Texture2D)FileLoader.Load(new Texture2D(renderCore.graphicsDevice,1,1));
renderCore.objects.Add(level.background);
level.obstacles = new List<IObstacle>();
List<Obstacle> list = FileLoader.loadList<Obstacle>();
foreach (Obstacle obstacle in list)
{
level.obstacles.Add(obstacle);
}
RenderGroup obstacleGroup = new RenderGroup("Obstacles");
foreach(IObstacle obstacle in level.obstacles)
{
obstacle.parent = renderCore;
obstacle.position = new Vector2(obstacle.position.X, obstacle.position.Y + renderCore.settings.screensize.Y - obstacle.getcurrentAnimation().size.Y);
Vector2 scale = new Vector2(renderCore.settings.screensize.X / renderCore.settings.standardsize.X, renderCore.settings.screensize.Y / renderCore.settings.standardsize.Y);
obstacle.position = new Vector2(obstacle.position.X * scale.X, obstacle.position.Y * scale.Y);
obstacle.layer = 1;
obstacleGroup.objects.Add(obstacle);
}
obstacleGroup.AddEverythingToRenderingCore(renderCore);
return level;
}
public async Task <int> Run()
{
var md = vn.Add(new TestDialogueBox());
var reimu = vn.Add(new Reimu());
await vn.Wait(0);
var rg2 = new RenderGroup(vn, "rg2", 2);
var rg3 = new RenderGroup(vn, "rg3", 3);
//Multiple render groups cannot have the same priority (at least not on initialization)
Assert.Throws <Exception>(() => new RenderGroup(vn, "rg4", 2));
reimu.AddToRenderGroup(rg2);
ListEq(rg2.Contents.ToArray(), new[] { reimu });
reimu.AddToRenderGroup(rg3);
ListEq(rg2.Contents.ToArray(), new IRendered[] { });
ListEq(rg3.Contents.ToArray(), new[] { reimu });
reimu.Location.Value = Vector3.One;
rg3.ZoomTarget.Value = reimu.Location;
await rg3.ZoomTo(2f, 3f);
return(1337);
}
public static void print_style(Style style, int index)
{
Console.WriteLine("\tstyle " + index.ToString() + " id: " + style.getId() + " applies to: ");
Console.WriteLine("\t\troles:" + style.createRoleString() +
" types: " + style.createTypeString());
if (!style.isSetGroup())
{
return;
}
RenderGroup group = style.getGroup();
if (group.isSetStroke())
{
Console.WriteLine("\t\tstroke: {0}", group.getStroke());
}
if (group.isSetFill())
{
Console.WriteLine("\t\tfill: {0}", group.getFill());
}
for (int j = 0; j < group.getNumElements(); ++j)
{
object element = group.getElement(j);
if (element is GraphicalPrimitive2D)
{
Console.WriteLine("\t\tsub element {0} stroke {1}, fill {2}", ((GraphicalPrimitive2D)element).getElementName(), ((GraphicalPrimitive2D)element).getStroke(), ((GraphicalPrimitive2D)element).getFill());
}
else if (element is GraphicalPrimitive1D)
{
Console.WriteLine("\t\tsub element {0} stroke {1}", ((GraphicalPrimitive1D)element).getElementName(), ((GraphicalPrimitive1D)element).getStroke());
}
}
}
private static UIComponent Create2DUIPage(RenderGroup renderGroup)
{
var entity = new Entity("Avalonia Screen Page " + renderGroup);
var uiPage = new UIComponent
{
RenderGroup = renderGroup,
Page = new UIPage
{
Name = "Screen Page " + renderGroup,
RootElement = new Canvas()
}
};
var game = AvaloniaLocator.Current.GetService <IGame>();
var width = game.GraphicsDevice.Presenter.Description.BackBufferWidth;
var height = game.GraphicsDevice.Presenter.Description.BackBufferHeight;
uiPage.Resolution = new Vector3(width, height, 1000);
ScreenPages.Add(renderGroup, uiPage);
entity.Add(uiPage);
Container2D.AddChild(entity);
return(uiPage);
}
internal static SubTankMesh FromModel(ModelVisual modelVisual, ModelPrimitive modelPrimitive, IPackageIndexer packageIndexer, Device device, ModelTextureManager textureManager)
{
if (modelVisual == null)
{
return(null);
}
if (modelPrimitive == null)
{
return(null);
}
var mesh = new SubTankMesh();
_textureManager = textureManager;
var verticesMap = new Dictionary <string, VertexState>();
foreach (var kv in modelPrimitive.Vertices)
{
var name = kv.Key;
var vlist = kv.Value;
verticesMap[name] = TankMesh.ConvertToVertexBuffer(vlist, device);
}
var indicesMap = new Dictionary <string, IndexBuffer>();
foreach (var kv in modelPrimitive.Indices)
{
var name = kv.Key;
var nlist = kv.Value;
indicesMap[name] = TankMesh.ConvertToIndexBuffer(nlist, device);
}
foreach (var renderSet in modelVisual.RenderSets)
{
//renderSet.Geometry.PrimitiveName
var vState = verticesMap[renderSet.Geometry.VerticesName];
var indices = indicesMap[renderSet.Geometry.IndicesName];
var rawVertices = modelPrimitive.Vertices[renderSet.Geometry.VerticesName].Vertices;
var rawIndices = modelPrimitive.Indices[renderSet.Geometry.IndicesName];
foreach (var groupKv in renderSet.Geometry.ModelPrimitiveGroups)
{
var group = groupKv.Value;
RenderGroup renderGroup = null;
if (group.Sectioned)
{
renderGroup = new RenderGroup
{
MinVertexIndex = (int)group.StartVertex,
VerticesCount = (int)group.VerticesCount,
StartIndex = (int)group.StartIndex,
PrimitiveCount = (int)group.PrimitiveCount,
};
}
else
{
renderGroup = new RenderGroup
{
MinVertexIndex = 0,
VerticesCount = vState.Count,
StartIndex = 0,
PrimitiveCount = ((int)indices.Tag) / 3,
};
}
renderGroup.VertexState = vState;
renderGroup.Indices = indices;
renderGroup.RawVertices = rawVertices;
renderGroup.RawIndices = rawIndices;
if (group.Material.ShowArmor)
{
renderGroup.RenderArmor = true;
renderGroup.Textures = null;
renderGroup.Armor = group.Material.Armor;
}
else
{
renderGroup.RenderArmor = false;
var textures = new Dictionary <string, ModelTexture>();
foreach (var property in group.Material.Propertys)
{
var texturePath = property.Texture;
if (string.IsNullOrWhiteSpace(texturePath))
{
if (property.Name == "alphaTestEnable" && group.Material.Fx != "shaders/std_effects/PBS_tank.fx")
{
renderGroup.AlphaTestEnable = property.BoolValue;
}
else
{
switch (property.Name)
{
case "alphaReference":
renderGroup.AlphaReference = property.IntValue;
break;
case "g_useNormalPackDXT1":
renderGroup.UseNormalPackDxt1 = property.BoolValue;
break;
case "g_detailPower":
renderGroup.DetailPower = property.FloatValue;
break;
case "g_metallicDetailUVTiling":
renderGroup.DetailUvTiling = property.Vector4Value;
break;
case "g_defaultPBSConversionParam":
break;
case "g_albedoConversions":
break;
case "g_glossConversions":
break;
case "g_metallicConversions":
break;
case "g_defaultPBSConversionParams":
break;
case "g_albedoCorrection":
break;
case "g_useDetailMetallic":
break;
case "g_maskBias":
break;
case "doubleSided":
break;
case "alphaTestEnable":
break;
case "crash_coefficient":
break;
default:
break;
}
}
}
else
{
try
{
var texture = textureManager.LoadTexture(packageIndexer, texturePath, device);
textures[property.Name] = texture;
if (property.Name == "normalMap" && !renderGroup.UseNormalBc1)
{
if (texture.ImageInformation.Format == Format.Dxt1)
{
renderGroup.UseNormalBc1 = true;
}
}
}
catch (Exception)
{
Log.InfoFormat("can't load texture {0} for {1}", texturePath, property.Name);
}
}
}
renderGroup.Textures = textures;
}
mesh._renderGroups.Add(renderGroup);
}
}
return(mesh);
}
public Frame(Game game, Vector2[] textureCoords)
{
this.textureCoords = textureCoords;
renderGroup = new RenderGroup(game);
resetRenderGroup();
}
private Entity CreateChildEntity(PhysicsComponent component, ColliderShape shape, RenderGroup renderGroup, bool addOffset)
{
if (shape == null)
{
return(null);
}
switch (shape.Type)
{
case ColliderShapeTypes.Compound:
{
var entity = new Entity();
//We got to recurse
var compound = (CompoundColliderShape)shape;
for (var i = 0; i < compound.Count; i++)
{
var subShape = compound[i];
var subEntity = CreateChildEntity(component, subShape, renderGroup, true); //always add offsets to compounds
if (subEntity != null)
{
entity.AddChild(subEntity);
}
}
entity.Transform.LocalMatrix = Matrix.Identity;
entity.Transform.UseTRS = false;
compound.DebugEntity = entity;
return(entity);
}
case ColliderShapeTypes.Box:
case ColliderShapeTypes.Capsule:
case ColliderShapeTypes.ConvexHull:
case ColliderShapeTypes.Cylinder:
case ColliderShapeTypes.Sphere:
case ColliderShapeTypes.Cone:
case ColliderShapeTypes.StaticPlane:
case ColliderShapeTypes.StaticMesh:
case ColliderShapeTypes.Heightfield:
{
IDebugPrimitive debugPrimitive;
var type = shape.GetType();
if (type == typeof(HeightfieldColliderShape) || type.BaseType == typeof(HeightfieldColliderShape))
{
if (!updatableDebugMeshCache.TryGetValue(shape, out debugPrimitive))
{
debugPrimitive = shape.CreateUpdatableDebugPrimitive(graphicsDevice);
updatableDebugMeshCache[shape] = debugPrimitive;
}
if (!updatableDebugMeshes.ContainsKey(shape))
{
updatableDebugMeshes.Add(shape, debugPrimitive);
}
}
else if (type == typeof(CapsuleColliderShape) || type == typeof(ConvexHullColliderShape) || type == typeof(StaticMeshColliderShape))
{
if (!debugMeshCache2.TryGetValue(shape, out debugPrimitive))
{
debugPrimitive = new DebugPrimitive {
shape.CreateDebugPrimitive(graphicsDevice)
};
debugMeshCache2[shape] = debugPrimitive;
}
}
else
{
if (!debugMeshCache.TryGetValue(shape.GetType(), out debugPrimitive))
{
debugPrimitive = new DebugPrimitive {
shape.CreateDebugPrimitive(graphicsDevice)
};
debugMeshCache[shape.GetType()] = debugPrimitive;
}
}
var model = new Model
{
GetMaterial(component, shape),
};
foreach (var meshDraw in debugPrimitive.GetMeshDraws())
{
model.Add(new Mesh {
Draw = meshDraw
});
}
var entity = new Entity
{
new ModelComponent
{
Model = model,
RenderGroup = renderGroup,
},
};
var offset = addOffset ? Matrix.RotationQuaternion(shape.LocalRotation) * Matrix.Translation(shape.LocalOffset) : Matrix.Identity;
entity.Transform.LocalMatrix = shape.DebugPrimitiveMatrix * offset * Matrix.Scaling(shape.Scaling);
entity.Transform.UseTRS = false;
shape.DebugEntity = entity;
return(entity);
}
default:
return(null);
}
}
protected override void updateRenderGroup(Game game, RenderGroup renderGroup)
{
renderGroup.addGuiRectangle(bounds, ColorMaker.black, RenderGroup.makeTextureCoords(0, 0));
}
public TransparencyInterface()
{
ObjectName = "";
RenderGroup = RenderGroup.None;
}
protected override void updateRenderGroup(Game game, RenderGroup renderGroup)
{
renderGroup.addGuiRectangle(buttonDown ? bounds : (bounds - buttonOffset), ColorMaker.gray(.3f));
renderGroup.addGuiRectangle(bounds + buttonOffset, ColorMaker.gray(.2f));
renderGroup.addGuiText((buttonDown ? bounds.position : (bounds.position - buttonOffset)) + bounds.halfSize + new Vector2(-(renderGroup.stringSize(text) / 2), -4), text, ColorMaker.white);
}
private void OnGUI()
{
if (this._toggled)
{
GUI.color = Color.white;
GUI.backgroundColor = Color.gray;
GUILayout.BeginArea(new Rect(10f, 10f, 250f, (float)(Screen.height - 20)), this._style);
for (int i = 0; i < this.renderGroups.Length; i++)
{
RenderGroup group = this.renderGroups[i];
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.Label(group.name, new GUILayoutOption[0]);
GUILayoutOption[] optionArray1 = new GUILayoutOption[] { GUILayout.Width(100f), GUILayout.Height(40f) };
if (GUILayout.Button("Toggle", optionArray1))
{
for (int j = 0; j < group.gameObjects.Length; j++)
{
group.gameObjects[j].SetActive(!group.gameObjects[j].activeSelf);
}
}
GUILayout.EndHorizontal();
}
GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.Height(50f) };
this._toggled = !GUILayout.Button("Close", options);
GUILayout.EndArea();
GUILayout.BeginArea(new Rect(260f, 10f, 250f, (float)(Screen.height - 20)), this._style);
GUILayout.Label(string.Format("FPS: {0}", 1f / Time.smoothDeltaTime), new GUILayoutOption[0]);
GUILayoutOption[] optionArray3 = new GUILayoutOption[] { GUILayout.Height(50f) };
if (GUILayout.Button("PostFX Toggle", optionArray3))
{
PostFXWithResScale scale = UnityEngine.Object.FindObjectOfType <PostFXWithResScale>();
if (scale != null)
{
scale.enabled = !scale.enabled;
}
}
GUILayoutOption[] optionArray4 = new GUILayoutOption[] { GUILayout.Height(50f) };
if (GUILayout.Button("HDR & HDR Buffer", optionArray4))
{
PostFXWithResScale scale2 = UnityEngine.Object.FindObjectOfType <PostFXWithResScale>();
if (scale2 != null)
{
bool hdr = Camera.main.hdr;
Camera.main.hdr = !hdr;
scale2.HDRBuffer = !hdr;
}
}
GUILayoutOption[] optionArray5 = new GUILayoutOption[] { GUILayout.Height(50f) };
if (GUILayout.Button("FXAA", optionArray5))
{
PostFXWithResScale scale3 = UnityEngine.Object.FindObjectOfType <PostFXWithResScale>();
if (scale3 != null)
{
scale3.FXAA = !scale3.FXAA;
}
}
GUILayoutOption[] optionArray6 = new GUILayoutOption[] { GUILayout.Height(50f) };
if (GUILayout.Button("Distortion Map", optionArray6))
{
PostFXWithResScale scale4 = UnityEngine.Object.FindObjectOfType <PostFXWithResScale>();
if (scale4 != null)
{
scale4.UseDistortion = !scale4.UseDistortion;
}
}
GUILayoutOption[] optionArray7 = new GUILayoutOption[] { GUILayout.Height(50f) };
if (GUILayout.Button("Distortion Apply", optionArray7))
{
PostFXWithResScale scale5 = UnityEngine.Object.FindObjectOfType <PostFXWithResScale>();
if (scale5 != null)
{
scale5.UseDistortion = !scale5.UseDistortion;
}
}
GUILayoutOption[] optionArray8 = new GUILayoutOption[] { GUILayout.Height(50f) };
if (GUILayout.Button("Use Distortion Depth Test", optionArray8))
{
PostFXWithResScale scale6 = UnityEngine.Object.FindObjectOfType <PostFXWithResScale>();
if (scale6 != null)
{
scale6.UseDepthTest = !scale6.UseDepthTest;
}
}
GUILayout.EndArea();
}
else
{
this._toggled = GUI.Button(new Rect(10f, 10f, 150f, 50f), "Render Scene");
}
}
/// <summary>
/// Called when road segment is placed/released.
/// </summary>
/// <param name="segmentID"></param>
/// <param name="laneID"></param>
/// <param name="laneInfo"></param>
/// <param name="startFlags"></param>
/// <param name="endFlags"></param>
/// <param name="startAngle"></param>
/// <param name="endAngle"></param>
/// <param name="invert"></param>
/// <param name="terrainHeight"></param>
/// <param name="layer"></param>
/// <param name="vertexIndex"></param>
/// <param name="triangleIndex"></param>
/// <param name="groupPosition"></param>
/// <param name="data"></param>
/// <param name="min"></param>
/// <param name="max"></param>
/// <param name="maxRenderDistance"></param>
/// <param name="maxInstanceDistance"></param>
/// <param name="hasProps"></param>
public void PopulateGroupData(ushort segmentID, uint laneID, NetInfo.Lane laneInfo, NetNode.Flags startFlags, NetNode.Flags endFlags, float startAngle, float endAngle, bool invert, bool terrainHeight, int layer, ref int vertexIndex, ref int triangleIndex, Vector3 groupPosition, RenderGroup.MeshData data, ref Vector3 min, ref Vector3 max, ref float maxRenderDistance, ref float maxInstanceDistance, ref bool hasProps)
{
var laneProps = laneInfo.m_laneProps;
if (laneProps != null && laneProps.m_props != null)
{
var flag = (byte)(laneInfo.m_finalDirection & NetInfo.Direction.Both) == 2 || (byte)(laneInfo.m_finalDirection & NetInfo.Direction.Avoid) == 11;
var flag2 = flag != invert;
if (flag)
{
var flags = startFlags;
startFlags = endFlags;
endFlags = flags;
}
var num = laneProps.m_props.Length;
// mod begin
var _this = NetManager.instance.m_lanes.m_buffer[laneID];
var streetLightPrefabDataIndices = PropCustomizer.Instance.StreetLightPrefabDataIndices;
var segmentData = SegmentDataManager.Instance.SegmentToSegmentDataMap?[_this.m_segment];
// mod end
for (var i = 0; i < num; i++)
{
var prop = laneProps.m_props[i];
if (prop.CheckFlags((NetLane.Flags)_this.m_flags, startFlags, endFlags))
{
if (_this.m_length >= prop.m_minLength)
{
// mod begin
var prop_m_angle = prop.m_angle;
var finalProp = prop.m_finalProp;
var finalTree = prop.m_finalTree;
var repeatDistance = prop.m_repeatDistance;
if (segmentData != null)
{
// custom street lights
if (finalProp != null)
{
var customLight = (segmentData.Features & SegmentData.FeatureFlags.StreetLight) != 0;
// Contains seems to be faster than array lookup
if ((customLight || segmentData.RepeatDistances.magnitude > 0f) && streetLightPrefabDataIndices.Contains(finalProp.m_prefabDataIndex))
{
if (customLight)
{
finalProp = segmentData.StreetLightPrefab;
if (laneInfo.m_position + prop.m_position.x < 0f) prop_m_angle = 180; //rotate street lights on pedestrian paths correctly
}
if (segmentData.RepeatDistances.w > 0f)
{
repeatDistance = segmentData.RepeatDistances.w;
}
}
}
// custom road trees
else if (finalTree != null)
{
if (laneInfo.m_position < 0) // Left Trees
{
if ((segmentData.Features & SegmentData.FeatureFlags.TreeLeft) != 0)
{
finalTree = segmentData.TreeLeftPrefab;
}
if (segmentData.RepeatDistances.x > 0f)
{
repeatDistance = segmentData.RepeatDistances.x;
}
}
else if (laneInfo.m_position == 0) // Middle Trees
{
if ((segmentData.Features & SegmentData.FeatureFlags.TreeMiddle) != 0)
{
finalTree = segmentData.TreeMiddlePrefab;
}
if (segmentData.RepeatDistances.y > 0f)
{
repeatDistance = segmentData.RepeatDistances.y;
}
}
else // Right Trees
{
if ((segmentData.Features & SegmentData.FeatureFlags.TreeRight) != 0)
{
finalTree = segmentData.TreeRightPrefab;
}
if (segmentData.RepeatDistances.z > 0f)
{
repeatDistance = segmentData.RepeatDistances.z;
}
}
}
}
// mod end
var num2 = 2;
if (repeatDistance > 1f)
{
num2 *= Mathf.Max(1, Mathf.RoundToInt(_this.m_length / repeatDistance));
}
var num3 = prop.m_segmentOffset * 0.5f;
if (_this.m_length != 0f)
{
num3 = Mathf.Clamp(num3 + prop.m_position.z / _this.m_length, -0.5f, 0.5f);
}
if (flag2)
{
num3 = -num3;
}
if (finalProp != null)
{
hasProps = true;
if (finalProp.m_prefabDataLayer == layer || finalProp.m_effectLayer == layer)
{
var color = Color.white;
var randomizer = new Randomizer((int)(laneID + (uint)i));
for (var j = 1; j <= num2; j += 2)
{
if (randomizer.Int32(100u) < prop.m_probability)
{
var num4 = num3 + (float)j / (float)num2;
var variation = finalProp.GetVariation(ref randomizer);
var scale = variation.m_minScale + (float)randomizer.Int32(10000u) * (variation.m_maxScale - variation.m_minScale) * 0.0001f;
if (prop.m_colorMode == NetLaneProps.ColorMode.Default)
{
color = variation.GetColor(ref randomizer);
}
var vector = _this.m_bezier.Position(num4);
if (terrainHeight)
{
vector.y = Singleton<TerrainManager>.instance.SampleDetailHeight(vector);
}
vector.y += prop.m_position.y;
var vector2 = _this.m_bezier.Tangent(num4);
if (vector2 != Vector3.zero)
{
if (flag2)
{
vector2 = -vector2;
}
vector2.y = 0f;
if (prop.m_position.x != 0f)
{
vector2 = Vector3.Normalize(vector2);
vector.x += vector2.z * prop.m_position.x;
vector.z -= vector2.x * prop.m_position.x;
}
var num5 = Mathf.Atan2(vector2.x, -vector2.z);
if (prop.m_cornerAngle != 0f || prop.m_position.x != 0f)
{
var num6 = endAngle - startAngle;
if (num6 > 3.14159274f)
{
num6 -= 6.28318548f;
}
if (num6 < -3.14159274f)
{
num6 += 6.28318548f;
}
var num7 = startAngle + num6 * num4;
num6 = num7 - num5;
if (num6 > 3.14159274f)
{
num6 -= 6.28318548f;
}
if (num6 < -3.14159274f)
{
num6 += 6.28318548f;
}
num5 += num6 * prop.m_cornerAngle;
if (num6 != 0f && prop.m_position.x != 0f)
{
var num8 = Mathf.Tan(num6);
vector.x += vector2.x * num8 * prop.m_position.x;
vector.z += vector2.z * num8 * prop.m_position.x;
}
}
var id = default(InstanceID);
id.NetSegment = segmentID;
num5 += prop_m_angle * 0.0174532924f;
PropInstance.PopulateGroupData(variation, layer, id, vector, scale, num5, color, ref vertexIndex, ref triangleIndex, groupPosition, data, ref min, ref max, ref maxRenderDistance, ref maxInstanceDistance);
}
}
}
}
}
if (finalTree != null)
{
hasProps = true;
if (finalTree.m_prefabDataLayer == layer)
{
var randomizer2 = new Randomizer((int)(laneID + (uint)i));
for (var k = 1; k <= num2; k += 2)
{
if (randomizer2.Int32(100u) < prop.m_probability)
{
var t = num3 + (float)k / (float)num2;
var variation2 = finalTree.GetVariation(ref randomizer2);
var scale2 = variation2.m_minScale + (float)randomizer2.Int32(10000u) * (variation2.m_maxScale - variation2.m_minScale) * 0.0001f;
var brightness = variation2.m_minBrightness + (float)randomizer2.Int32(10000u) * (variation2.m_maxBrightness - variation2.m_minBrightness) * 0.0001f;
var vector3 = _this.m_bezier.Position(t);
if (terrainHeight)
{
vector3.y = Singleton<TerrainManager>.instance.SampleDetailHeight(vector3);
}
vector3.y += prop.m_position.y;
if (prop.m_position.x != 0f)
{
var vector4 = _this.m_bezier.Tangent(t);
if (flag2)
{
vector4 = -vector4;
}
vector4.y = 0f;
vector4 = Vector3.Normalize(vector4);
vector3.x += vector4.z * prop.m_position.x;
vector3.z -= vector4.x * prop.m_position.x;
}
global::TreeInstance.PopulateGroupData(variation2, vector3, scale2, brightness, ref vertexIndex, ref triangleIndex, groupPosition, data, ref min, ref max, ref maxRenderDistance, ref maxInstanceDistance);
}
}
}
}
}
}
}
}
}
/// <summary>
/// Called when road segment is placed/released.
/// </summary>
/// <param name="laneID"></param>
/// <param name="laneInfo"></param>
/// <param name="startFlags"></param>
/// <param name="endFlags"></param>
/// <param name="invert"></param>
/// <param name="layer"></param>
/// <param name="vertexCount"></param>
/// <param name="triangleCount"></param>
/// <param name="objectCount"></param>
/// <param name="vertexArrays"></param>
/// <param name="hasProps"></param>
/// <returns></returns>
public bool CalculateGroupData(uint laneID, NetInfo.Lane laneInfo, NetNode.Flags startFlags, NetNode.Flags endFlags, bool invert, int layer, ref int vertexCount, ref int triangleCount, ref int objectCount, ref RenderGroup.VertexArrays vertexArrays, ref bool hasProps)
{
var result = false;
var laneProps = laneInfo.m_laneProps;
if (laneProps != null && laneProps.m_props != null)
{
var flag = (byte)(laneInfo.m_finalDirection & NetInfo.Direction.Both) == 2 || (byte)(laneInfo.m_finalDirection & NetInfo.Direction.Avoid) == 11;
if (flag)
{
var flags = startFlags;
startFlags = endFlags;
endFlags = flags;
}
var num = laneProps.m_props.Length;
// mod begin
var _this = NetManager.instance.m_lanes.m_buffer[laneID];
var streetLightPrefabDataIndices = PropCustomizer.Instance.StreetLightPrefabDataIndices;
var segmentData = SegmentDataManager.Instance.SegmentToSegmentDataMap?[_this.m_segment];
// mod end
for (var i = 0; i < num; i++)
{
var prop = laneProps.m_props[i];
if (prop.CheckFlags((NetLane.Flags)_this.m_flags, startFlags, endFlags))
{
if (_this.m_length >= prop.m_minLength)
{
// mod begin
var finalProp = prop.m_finalProp;
var finalTree = prop.m_finalTree;
var repeatDistance = prop.m_repeatDistance;
if (segmentData != null)
{
// custom street lights
if (finalProp != null)
{
var customLight = (segmentData.Features & SegmentData.FeatureFlags.StreetLight) != 0;
// Contains seems to be faster than array lookup
if ((customLight || segmentData.RepeatDistances.magnitude > 0f) && streetLightPrefabDataIndices.Contains(finalProp.m_prefabDataIndex))
{
if (customLight)
{
finalProp = segmentData.StreetLightPrefab;
}
if (segmentData.RepeatDistances.w > 0f)
{
repeatDistance = segmentData.RepeatDistances.w;
}
}
}
// custom road trees
else if (finalTree != null)
{
if (laneInfo.m_position < 0) // Left Trees
{
if ((segmentData.Features & SegmentData.FeatureFlags.TreeLeft) != 0)
{
finalTree = segmentData.TreeLeftPrefab;
}
if (segmentData.RepeatDistances.x > 0f)
{
repeatDistance = segmentData.RepeatDistances.x;
}
}
else if (laneInfo.m_position == 0) // Middle Trees
{
if ((segmentData.Features & SegmentData.FeatureFlags.TreeMiddle) != 0)
{
finalTree = segmentData.TreeMiddlePrefab;
}
if (segmentData.RepeatDistances.y > 0f)
{
repeatDistance = segmentData.RepeatDistances.y;
}
}
else // Right Trees
{
if ((segmentData.Features & SegmentData.FeatureFlags.TreeRight) != 0)
{
finalTree = segmentData.TreeRightPrefab;
}
if (segmentData.RepeatDistances.z > 0f)
{
repeatDistance = segmentData.RepeatDistances.z;
}
}
}
}
// mod end
var num2 = 2;
if (repeatDistance > 1f)
{
num2 *= Mathf.Max(1, Mathf.RoundToInt(_this.m_length / repeatDistance));
}
if (finalProp != null)
{
hasProps = true;
if (finalProp.m_prefabDataLayer == layer || finalProp.m_effectLayer == layer)
{
var randomizer = new Randomizer((int)(laneID + (uint)i));
for (var j = 1; j <= num2; j += 2)
{
if (randomizer.Int32(100u) < prop.m_probability)
{
var variation = finalProp.GetVariation(ref randomizer);
randomizer.Int32(10000u);
variation.GetColor(ref randomizer);
if (PropInstance.CalculateGroupData(variation, layer, ref vertexCount, ref triangleCount, ref objectCount, ref vertexArrays))
{
result = true;
}
}
}
}
}
if (finalTree != null)
{
hasProps = true;
if (finalTree.m_prefabDataLayer == layer)
{
var randomizer2 = new Randomizer((int)(laneID + (uint)i));
for (var k = 1; k <= num2; k += 2)
{
if (randomizer2.Int32(100u) < prop.m_probability)
{
finalTree.GetVariation(ref randomizer2);
randomizer2.Int32(10000u);
randomizer2.Int32(10000u);
if (global::TreeInstance.CalculateGroupData(ref vertexCount, ref triangleCount, ref objectCount, ref vertexArrays))
{
result = true;
}
}
}
}
}
}
}
}
}
return result;
}
protected abstract void updateRenderGroup(Game game, RenderGroup renderGroup);
public void GetInstanceData(RenderGroup instancer)
{
throw new NotImplementedException();
}
public static byte GetQueue(RenderGroup group)
{
return(queueGroups[(int)group]);
}
protected override void EndRenderingImpl(RenderManager.CameraInfo cameraInfo)
{
FastList <RenderGroup> renderedGroups = Singleton <RenderManager> .instance.m_renderedGroups;
this.m_nameInstanceBuffer.Clear();
this.m_visibleRoadNameSegment = 0;
this.m_visibleTrafficLightNode = 0;
for (int groupIndex = 0; groupIndex < renderedGroups.m_size; groupIndex++)
{
RenderGroup renderGroup = renderedGroups.m_buffer[groupIndex];
if (renderGroup.m_instanceMask != 0)
{
const int resolutionRatio = NODEGRID_RESOLUTION / RenderManager.GROUP_RESOLUTION; // = 270/45 = 6
int net_x0 = renderGroup.m_x * resolutionRatio;
int net_z0 = renderGroup.m_z * resolutionRatio;
int net_x1 = (renderGroup.m_x + 1) * resolutionRatio - 1; // = net_x + 5
int net_z1 = (renderGroup.m_z + 1) * resolutionRatio - 1; // = net_z + 5
for (int net_z = net_z0; net_z <= net_z1; net_z++)
{
for (int net_x = net_x0; net_x <= net_x1; net_x++)
{
int gridIndex = net_z * NODEGRID_RESOLUTION + net_x;
ushort nodeID = this.m_nodeGrid[gridIndex];
int watchdog = 0;
while (nodeID != 0)
{
nodeID.ToNode().RenderInstance(cameraInfo, nodeID, renderGroup.m_instanceMask);
nodeID = nodeID.ToNode().m_nextGridNode;
if (++watchdog >= 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
for (int net_z = net_z0; net_z <= net_z1; net_z++)
{
for (int net_x = net_x0; net_x <= net_x1; net_x++)
{
int gridIndex = net_z * 270 + net_x;
ushort segmentID = this.m_segmentGrid[gridIndex];
int watchdog = 0;
while (segmentID != 0)
{
this.m_segments.m_buffer[(int)segmentID].RenderInstance(cameraInfo, segmentID, renderGroup.m_instanceMask);
segmentID = this.m_segments.m_buffer[(int)segmentID].m_nextGridSegment;
if (++watchdog >= 36864)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
}
}
this.m_lastVisibleRoadNameSegment = this.m_visibleRoadNameSegment;
this.m_lastVisibleTrafficLightNode = this.m_visibleTrafficLightNode;
int num11 = PrefabCollection <NetInfo> .PrefabCount();
for (int n = 0; n < num11; n++)
{
NetInfo prefab = PrefabCollection <NetInfo> .GetPrefab((uint)n);
if (prefab != null)
{
if (prefab.m_segments != null)
{
for (int num12 = 0; num12 < prefab.m_segments.Length; num12++)
{
NetInfo.Segment segment = prefab.m_segments[num12];
NetInfo.LodValue combinedLod = segment.m_combinedLod;
if (combinedLod != null && combinedLod.m_lodCount != 0)
{
NetSegment.RenderLod(cameraInfo, combinedLod);
}
}
}
if (prefab.m_nodes != null)
{
for (int num13 = 0; num13 < prefab.m_nodes.Length; num13++)
{
NetInfo.Node node = prefab.m_nodes[num13];
NetInfo.LodValue combinedLod2 = node.m_combinedLod;
if (combinedLod2 != null && combinedLod2.m_lodCount != 0)
{
if (node.m_directConnect)
{
NetSegment.RenderLod(cameraInfo, combinedLod2);
}
else
{
NetNode.RenderLod(cameraInfo, combinedLod2);
}
}
}
}
}
}
}
private Entity CreateChildEntity(PhysicsComponent component, ColliderShape shape, RenderGroup renderGroup, bool addOffset)
{
if (shape == null)
{
return(null);
}
switch (shape.Type)
{
case ColliderShapeTypes.Compound:
{
var entity = new Entity();
//We got to recurse
var compound = (CompoundColliderShape)shape;
for (var i = 0; i < compound.Count; i++)
{
var subShape = compound[i];
var subEntity = CreateChildEntity(component, subShape, renderGroup, true); //always add offsets to compounds
if (subEntity != null)
{
entity.AddChild(subEntity);
}
}
entity.Transform.LocalMatrix = Matrix.Identity;
entity.Transform.UseTRS = false;
compound.DebugEntity = entity;
return(entity);
}
case ColliderShapeTypes.Box:
case ColliderShapeTypes.Capsule:
case ColliderShapeTypes.ConvexHull:
case ColliderShapeTypes.Cylinder:
case ColliderShapeTypes.Sphere:
case ColliderShapeTypes.Cone:
{
var mat = triggerMaterial;
var rigidbodyComponent = component as RigidbodyComponent;
if (rigidbodyComponent != null)
{
mat = rigidbodyComponent.IsKinematic ? kinematicMaterial : dynamicMaterial;
mat = rigidbodyComponent.IsTrigger ? triggerMaterial : mat;
}
else if (component is CharacterComponent)
{
mat = characterMaterial;
}
else if (component is StaticColliderComponent)
{
var staticCollider = (StaticColliderComponent)component;
mat = staticCollider.IsTrigger ? triggerMaterial : staticMaterial;
}
MeshDraw draw;
var type = shape.GetType();
if (type == typeof(CapsuleColliderShape) || type == typeof(ConvexHullColliderShape))
{
if (!debugMeshCache2.TryGetValue(shape, out draw))
{
draw = shape.CreateDebugPrimitive(graphicsDevice);
debugMeshCache2[shape] = draw;
}
}
else
{
if (!debugMeshCache.TryGetValue(shape.GetType(), out draw))
{
draw = shape.CreateDebugPrimitive(graphicsDevice);
debugMeshCache[shape.GetType()] = draw;
}
}
var entity = new Entity
{
new ModelComponent
{
Model = new Model
{
mat,
new Mesh
{
Draw = draw
}
},
RenderGroup = renderGroup,
}
};
var offset = addOffset ? Matrix.RotationQuaternion(shape.LocalRotation) * Matrix.Translation(shape.LocalOffset) : Matrix.Identity;
entity.Transform.LocalMatrix = shape.DebugPrimitiveMatrix * offset * Matrix.Scaling(shape.Scaling);
entity.Transform.UseTRS = false;
shape.DebugEntity = entity;
return(entity);
}
default:
return(null);
}
}
public void SetDebugShape(DebugShapeType type, RenderGroup renderGroup)
{
var needToCreateNew = false;
needToCreateNew |= (type != debugShapeType && type != DebugShapeType.None);
debugShapeType = type;
var needToDeleteOld = (needToCreateNew || (type == DebugShapeType.None));
// Delete the old implementation if it still persists
if (needToDeleteOld && debugEntity != null)
{
scene.Entities.Remove(debugEntity);
debugEntity = null;
}
if (!needToCreateNew || debugEntity != null)
{
return;
}
DebugShape debugShape;
switch (type)
{
case DebugShapeType.Cone:
debugShape = new DebugShapeCone();
break;
case DebugShapeType.Cube:
debugShape = new DebugShapeCube();
break;
case DebugShapeType.Cylinder:
debugShape = new DebugShapeCylinder();
break;
case DebugShapeType.Torus:
debugShape = new DebugShapeTorus();
break;
default:
case DebugShapeType.Sphere:
debugShape = new DebugShapeSphere();
break;
}
debugEntity = new Entity
{
new ModelComponent
{
Model = new Model
{
material,
new Mesh
{
Draw = debugShape.CreateDebugPrimitive(graphicsDevice)
}
},
RenderGroup = renderGroup,
}
};
scene.Entities.Add(debugEntity);
debugEntity.Enable <ModelComponent>();
}
public static bool Contains(this RenderGroupMask mask, RenderGroup group)
{
return(((uint)mask & (1 << (int)group)) != 0);
}
private void PrepareLightGroups(RenderDrawContext context, FastList <RenderView> renderViews, RenderView renderView, RenderViewLightData renderViewData, IShadowMapRenderer shadowMapRenderer, RenderGroup group)
{
var viewIndex = renderViews.IndexOf(renderView);
foreach (var activeRenderer in renderViewData.ActiveRenderers)
{
// Find lights
var lightCollection = activeRenderer.LightGroup.FindLightCollectionByGroup(group);
// Light collections aren't cleared (see ClearCache). Can be null after switching to empty scenes.
if (lightCollection is null)
{
continue;
}
// Indices of lights in lightCollection that need processing
lightIndicesToProcess.Clear();
for (int i = 0; i < lightCollection.Count; i++)
{
lightIndicesToProcess.Add(i);
}
// Loop over all the renderers in order
int rendererIndex = 0;
foreach (var renderer in activeRenderer.Renderers)
{
var processLightsParameters = new LightGroupRendererBase.ProcessLightsParameters
{
Context = context,
ViewIndex = viewIndex,
View = renderView,
Views = renderViews,
Renderers = activeRenderer.Renderers,
RendererIndex = rendererIndex++,
LightCollection = lightCollection,
LightIndices = lightIndicesToProcess,
LightType = activeRenderer.LightGroup.LightType,
ShadowMapRenderer = shadowMapRenderer,
ShadowMapTexturesPerLight = renderViewData.RenderLightsWithShadows,
};
renderer.ProcessLights(processLightsParameters);
}
}
}
public static byte GetQueue(RenderGroup group, byte offset)
{
return((byte)(queueGroups[(int)group] + offset));
}
private Entity CreateChildEntity(PhysicsComponent component, ColliderShape shape, RenderGroup renderGroup, bool addOffset)
{
if (shape == null)
{
return(null);
}
switch (shape)
{
case BoxColliderShape _:
case ConvexHullColliderShape _:
case SphereColliderShape _:
case CylinderColliderShape _:
case CapsuleColliderShape _:
case MeshColliderShape _:
{
IDebugPrimitive debugPrimitive;
var shapeType = shape.GetType();
if (shapeType == typeof(CapsuleColliderShape) || shapeType == typeof(ConvexHullColliderShape) || shapeType == typeof(MeshColliderShape))
{
if (!debugMeshCache2.TryGetValue(shape, out debugPrimitive))
{
debugPrimitive = new DebugPrimitive {
shape.CreateDebugPrimitive(graphicsDevice)
};
debugMeshCache2[shape] = debugPrimitive;
}
}
else
{
if (!debugMeshCache.TryGetValue(shape.GetType(), out debugPrimitive))
{
debugPrimitive = new DebugPrimitive {
shape.CreateDebugPrimitive(graphicsDevice)
};
debugMeshCache[shape.GetType()] = debugPrimitive;
}
}
var model = new Model
{
GetMaterial(component, shape),
};
foreach (var meshDraw in debugPrimitive.GetMeshDraws())
{
model.Add(new Mesh {
Draw = meshDraw
});
}
var entity = new Entity
{
new ModelComponent
{
Model = model,
RenderGroup = renderGroup,
},
};
var offset = addOffset ? Matrix.RotationQuaternion(shape.LocalRotation) * Matrix.Translation(shape.LocalOffset) : Matrix.Identity;
entity.Transform.LocalMatrix = shape.DebugPrimitiveMatrix * offset * Matrix.Scaling(shape.Scaling);
entity.Transform.UseTRS = false;
shape.DebugEntity = entity;
return(entity);
}
default:
return(null);
}
}
private void initWall(Game game)
{
if (flags.HasFlag(WallFlag.flat)) {
renderGroup = new RenderGroup(game);
renderGroup.begin(BeginMode.Quads);
renderGroup.addTop(-MathCustom.vect3PointFive, MathCustom.vect3PointFive, null, texCoordsFlat);
renderGroup.end();
}
}
