public static void Render(RenderManager.CameraInfo cameraInfo, AngleMeasurement angle)
{
if (angle.HideOverlay)
return;
var renderManager = RenderManager.instance;
var centreAngle = Vector3.Angle(Vector3.right, angle.AngleNormal);
if (Vector3.Cross(Vector3.right, angle.AngleNormal).y > 0f)
centreAngle = -centreAngle;
var arcs = BezierUtil.CreateArc(angle.Position, GetAngleDistance(angle.Flags),
centreAngle - angle.AngleSize*.5f,
centreAngle + angle.AngleSize*.5f);
for (var i = 0; i < arcs.Count; i++) {
var isFirst = i == 0;
var isLast = i == arcs.Count - 1;
renderManager.OverlayEffect.DrawBezier(cameraInfo, GetAngleColor(angle.Flags), arcs[i], .7f, 0f, 0f,
angle.Position.y - 20f,
angle.Position.y + 20f, false, true);
}
}
public override void Draw(RenderManager renderMgr, Camera camera)
{
int xStart = (int)((camera.Center.X - camera.Size.X * 0.5f) / TileWidth);
int xEnd = (int)(1 + (camera.Center.X + camera.Size.X * 0.5f) / TileWidth);
var yStart = (int)((camera.Center.Y - camera.Size.Y * 0.5f) / TileHeight);
var yEnd = (int)(1 + (camera.Center.Y + camera.Size.Y * 0.5f) / TileHeight); ;
if (xStart < 0)
xStart = 0;
if (xEnd > MapWidth - 1)
xEnd = MapWidth - 1;
if (yStart < 0)
yStart = 0;
if (yEnd > MapHeight - 1)
yEnd = MapHeight - 1;
for (var i = xStart; i < xEnd; i++)
{
for (var j = yStart; j < yEnd; j++)
{
if (Tiles[i, j].Texture == null)
continue;
var position = new Vector2f(
TileWidth * i + TileWidth * 0.5f,
TileHeight * j + TileHeight * 0.5f);
renderMgr.DrawSprite(Tiles[i, j].Texture, Tiles[i, j].SubImageRect, position + WorldPosition, TileWidth, TileHeight, false, false, Tint, ZIndex);
}
}
}
public void Draw(RenderManager renderMgr)
{
IntRect subImageRect = new IntRect(0, 0, (int) texture.Size.X, (int) texture.Size.Y);
Vector2f centerPos = new Vector2f(box.Left + box.Width * 0.5f, box.Top + box.Height * 0.5f);
renderMgr.DrawSprite(texture, subImageRect, centerPos, box.Width, box.Height, false, false, new Color(255, 255, 255, 255), 10000);
}
public Camera(IDataReader state, RenderManager renderManager)
: base(state)
{
addInterface(typeof(ICamera));
m_renderManager = renderManager;
m_renderTargetId = new XnaScrapId(state);
IRenderTarget renderTarget = m_renderManager.getRenderTarget(m_renderTargetId);
if (renderTarget != null)
{
renderTarget.Cameras.Add(this);
}
m_fovy = state.ReadSingle();
m_near = state.ReadSingle();
m_far = state.ReadSingle();
m_aspect = state.ReadSingle();
float f = m_fovy * (float)Math.PI / 180.0f;
m_projection = Matrix.CreatePerspectiveFieldOfView(f, m_aspect, m_near, m_far);
m_viewport = new _Viewport(state);
m_renderManager.Cameras.Add(new XnaScrapId("ImplementCameraNamingYouJerk!"), this);
}
public override void RenderGeometry(RenderManager.CameraInfo cameraInfo) {
base.RenderGeometry(cameraInfo);
if (isHoveringSegment) {
m_toolController.RenderCollidingNotifications(cameraInfo, 0, 0);
}
}
public RenderComponent(RenderManager renderMgr, GameObject parent)
: base(parent)
{
Manager = renderMgr;
Tint = new Color(255, 255, 255, 255);
}
public GameManagerImpl(Game game)
: base(game)
{
rendererManager = new RenderManager(this);
collisionManager = new CollisionManager(this);
logicManager = new LogicManager(this);
}
public static void RenderInstance(ref Building b, RenderManager.CameraInfo cameraInfo, ushort buildingID,
int layerMask)
{
if ((b.m_flags & (Building.Flags.Created | Building.Flags.Deleted | Building.Flags.Hidden)) != Building.Flags.Created)
return;
BuildingInfo info = b.Info;
//begin mod
if (info == null)
{
return;
}
var ai = info.m_buildingAI;
if ((layerMask & 1 << info.m_prefabDataLayer) == 0 && !(ai is PlayerBuildingAI || ai is DecorationBuildingAI/* || ai is DummyBuildingAI*/)) //TODO(earalov): do we need to uncomment that?
//end mod
return;
Vector3 point = b.m_position;
float radius = info.m_renderSize + (float)b.m_baseHeight * 0.5f;
point.y += (float)(((double)info.m_size.y - (double)b.m_baseHeight) * 0.5);
if (!cameraInfo.Intersect(point, radius))
return;
RenderManager instance = Singleton<RenderManager>.instance;
uint instanceIndex;
if (!instance.RequireInstance((uint)buildingID, 1U, out instanceIndex))
return;
RenderInstance(ref b, cameraInfo, buildingID, layerMask, info, ref instance.m_instances[(uint)instanceIndex]);
}
public Quad(int startX,int endX, int startZ, int endZ, Base.Content.Terrain.Terrain terrain, RenderManager renderer)
{
_bounds = new QuadBounds
{
MinX = startX / terrain.PointsPerMeter,
MaxX = endX / terrain.PointsPerMeter,
MinZ = startZ / terrain.PointsPerMeter,
MaxZ = endZ / terrain.PointsPerMeter,
MinY = terrain.Height[0],
MaxY = terrain.Height[0]
};
HorizontalCenter = new Vector2(Bounds.MinX + (Bounds.MaxX - Bounds.MinX) / 2, Bounds.MinZ + (Bounds.MaxZ - Bounds.MinZ) / 2);
int verticesX = endX - startX + 1;
int verticesZ = endZ - startZ + 1;
var dataStream = new DataStream(32 * verticesX * verticesZ, true, true);
for (int i = 0; i < verticesX; i++)
{
for (int j = 0; j < verticesZ; j++)
{
//Position
int xindex = Math.Min(i + startX, terrain.PointsX - 1);//Clamp to arraybounds if neccessary
int zindex = Math.Min(j + startZ, terrain.PointsZ - 1);//(Quadsize needs to be consistent for sharing IndexBuffers)
float x = xindex / terrain.PointsPerMeter;
float z = zindex / terrain.PointsPerMeter;
float y = terrain.Height[xindex * terrain.PointsZ + zindex];
dataStream.Write(new Vector3(x, y, z));
//Normal
float deltax = (terrain.Height[(xindex < terrain.PointsX - 1 ? xindex + 1 : xindex) * terrain.PointsZ + zindex]
- terrain.Height[(xindex != 0 ? xindex - 1 : xindex) * terrain.PointsZ + zindex]);
float deltaz = (terrain.Height[xindex * terrain.PointsZ + (zindex < terrain.PointsZ - 1 ? zindex + 1 : zindex)]
- terrain.Height[xindex * terrain.PointsZ + (zindex != 0 ? zindex - 1 : zindex)]);
if (xindex == 0 || xindex == terrain.PointsX - 1)
deltax *= 2;
if (zindex == 0 || zindex == terrain.PointsZ - 1)
deltaz *= 2;
var normal = new Vector3(-deltax, 2 / terrain.PointsPerMeter, deltaz);
normal.Normalize();
dataStream.Write(normal);
//TextureCoordinates
dataStream.Write(new Vector2(x / terrain.PointsX, z / terrain.PointsZ));
//Boundingbox-Params
if (y < _bounds.MinY)
_bounds.MinY = y;
if (y > _bounds.MaxY)
_bounds.MaxY = y;
}
}
dataStream.Position = 0;
VBuffer = new Buffer(renderer.D3DDevice, dataStream, 32 * verticesX * verticesZ, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
VertexBuffer = new VertexBufferBinding(VBuffer, 32, 0);
dataStream.Dispose();
}
protected override void OnLoad(EventArgs e)
{
InputManager.Initialize(this.Mouse);
this.renderer = new RenderManager();
this.game = new GameManager(this);
}
protected override void Initialize () {
base.Initialize();
RenderManager = new RenderManager(GraphicsDevice);
GraphicsDevice.DeviceResetting += new EventHandler<EventArgs>(OnDeviceResetting);
GraphicsDevice.DeviceReset += new EventHandler<EventArgs>(OnDeviceReset);
}
public RectRenderComponent(float width, float height, Color color, RenderManager renderMgr, GameObject parent)
: base(renderMgr, parent)
{
WorldWidth = width;
WorldHeight = height;
RectShape = new RectangleShape(new SFML.Window.Vector2f(width, height));
RectShape.FillColor = color;
ZIndex = int.MaxValue - 10000;
}
/// <summary>
/// Constructs a render coordinator.
/// </summary>
/// <param name="manager">The render manager responsible for creating frames and dispatching them to the graphics device.</param>
/// <param name="synchronousBeginDraw">The function responsible for synchronously beginning a rendering operation. This will be invoked on the rendering thread.</param>
/// <param name="synchronousEndDraw">The function responsible for synchronously ending a rendering operation and presenting it to the screen. This will be invoked on the rendering thread.</param>
public RenderCoordinator(RenderManager manager, Func<bool> synchronousBeginDraw, Action synchronousEndDraw)
{
Manager = manager;
_SyncBeginDraw = synchronousBeginDraw;
_SyncEndDraw = synchronousEndDraw;
CoreInitialize();
}
public void SetWorldPosition(RenderManager.CameraInfo camera, Vector3 worldPos)
{
var uiView = GetUIView();
var vector3_1 = Camera.main.WorldToScreenPoint(worldPos) / uiView.inputScale;
var vector3_3 = uiView.ScreenPointToGUI(vector3_1) - new Vector2(size.x * 0.5f, size.y * 0.5f);// + new Vector2(vector3_2.x, vector3_2.y);
relativePosition = vector3_3;
}
/// <summary>
/// Constructs a render coordinator. A render manager and synchronous draw methods are automatically provided for you.
/// </summary>
/// <param name="deviceService"></param>
public RenderCoordinator(IGraphicsDeviceService deviceService)
{
Manager = new RenderManager(deviceService.GraphicsDevice);
_SyncBeginDraw = DefaultBeginDraw;
_SyncEndDraw = DefaultEndDraw;
CoreInitialize();
}
public override void Draw(RenderManager renderMgr, Camera camera)
{
if (DebugDraw)
{
WorldPosition = Parent.Position;
RectShape.Position = Parent.Position - new Vector2f(RectShape.Size.X * 0.5f, RectShape.Size.Y * 0.5f);
renderMgr.Target.Draw(RectShape);
}
}
public SpriteRenderComponent(RenderManager renderMgr, GameObject parent, Texture texture, IntRect subImageRect)
: base(renderMgr, parent)
{
Texture = texture;
WorldPosition = parent.Position;
SubImageRect = subImageRect;
WorldWidth = SubImageRect.Width;
WorldHeight = SubImageRect.Height;
FlipX = false;
FlipY = false;
Tint = new Color(255, 255, 255, 255);
}
public D2DInteropHandler(RenderManager manager)
{
Manager = manager;
#if DEBUG
D3DDevice10 = new D3D101.Device1(manager.DXGIAdapter, D3D10.DriverType.Hardware, D3D10.DeviceCreationFlags.BgraSupport | D3D10.DeviceCreationFlags.Debug, D3D101.FeatureLevel.Level_10_0);
#else
D3DDevice10 = new D3D101.Device1(D3D10.DriverType.Hardware, D3D10.DeviceCreationFlags.BgraSupport, D3D101.FeatureLevel.Level_10_0);
#endif
D2DFactory = new D2D.Factory(D2D.FactoryType.SingleThreaded);
DWFactory = new DW.Factory(DW.FactoryType.Shared);
}
public override void Draw(RenderManager renderMgr, Camera camera)
{
renderMgr.DrawSprite(
CurrentSprite.Texture,
CurrentSprite.SubImageRect,
WorldPosition,
WorldWidth,
WorldHeight,
FlipX,
FlipY,
Tint, ZIndex);
}
public SpriteRenderComponent(RenderManager renderMgr, GameObject parent, Texture texture)
: base(renderMgr, parent)
{
Texture = texture;
WorldPosition = parent.Position;
SubImageRect.Top = 0;
SubImageRect.Left = 0;
SubImageRect.Width = (int)texture.Size.X;
SubImageRect.Height = (int)texture.Size.Y;
WorldWidth = SubImageRect.Width;
WorldHeight = SubImageRect.Height;
FlipX = false;
FlipY = false;
Tint = new Color(255, 255, 255, 255);
}
public Game()
{
m_Graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
// Create the state manager
m_StateManager = new StateManager( "GameStateManager" );
// Create and set up the render manager
m_RenderManager = new RenderManager();
m_RenderManager.ContentManager = this.Content;
m_RenderManager.GraphicsDeviceManager = m_Graphics;
// Scene Manager
m_SceneManager = new SceneManager();
}
public static void Render(RenderManager.CameraInfo cameraInfo, DistanceMeasurement distance)
{
var renderManager = RenderManager.instance;
if (!distance.IsStraight || distance.HideOverlay)
return;
var minHeight = Mathf.Min(distance.StartPosition.y, distance.EndPosition.y);
var maxHeight = Mathf.Max(distance.StartPosition.y, distance.EndPosition.y);
renderManager.OverlayEffect.DrawSegment(cameraInfo,
distance.Flags == MeasurementFlags.Primary ? Settings.PrimaryColor : Settings.SecondaryColor,
new Segment3(distance.StartPosition, distance.EndPosition), Size, 3f,
minHeight - 20f,
maxHeight + 20f, true, true);
}
/// <summary>
/// Constructs a render coordinator.
/// </summary>
/// <param name="manager">The render manager responsible for creating frames and dispatching them to the graphics device.</param>
/// <param name="synchronousBeginDraw">The function responsible for synchronously beginning a rendering operation. This will be invoked on the rendering thread.</param>
/// <param name="synchronousEndDraw">The function responsible for synchronously ending a rendering operation and presenting it to the screen. This will be invoked on the rendering thread.</param>
public RenderCoordinator(
RenderManager manager,
Func<bool> synchronousBeginDraw, Action synchronousEndDraw
)
{
Manager = manager;
ThreadGroup = manager.ThreadGroup;
UseResourceLock = manager.UseResourceLock;
CreateResourceLock = manager.CreateResourceLock;
_SyncBeginDraw = synchronousBeginDraw;
_SyncEndDraw = synchronousEndDraw;
DrawQueue = ThreadGroup.GetQueueForType<DrawTask>();
CoreInitialize();
}
public MainWindow()
{
InitializeComponent();
InitScene();
ComponentDispatcher.ThreadIdle += new System.EventHandler(UpdateLogic);
ModelManager.LoadModels();
this.MouseDown += OnMouseKey;
RenderOptions.ProcessRenderMode = RenderMode.Default;
Debug.WriteLine("Render Tier: " + (RenderCapability.Tier >> 16));
Input = new ApplicationInputManager(this);
appStateManager = new AppStateManager(this);
GameState = new GameState();
RenderManager = new RenderManager(this);
appStateManager.addAppState("GameState", GameState);
}
protected override void CreateScene()
{
ViewCamera camera = new ViewCamera("Camera", new Vector3(0f, 0f, 5f), Vector3.Zero);
RenderManager.SetActiveCamera(camera.Entity);
EntityManager.Add(camera.Entity);
CreateCube("Cube1", Vector3.Zero);
CreateCube("Cube2", new Vector3(5f, 0f, 0f));
CreateCube("Cube3", new Vector3(-5f, 0f, 0f));
CreateCube("Cube4", new Vector3(5f, 0f, 5f));
CreateCube("Cube5", new Vector3(-5f, 0f, 5f));
CreateCube("Cube6", new Vector3(5f, 0f, -5f));
CreateCube("Cube7", new Vector3(-5f, 0f, -5f));
CreateCube("Cube8", new Vector3(0f, 0f, 5f));
CreateCube("Cube9", new Vector3(0f, 0f, -5f));
}
public void ChangeTexture(int number)
{
if (renderingDropdownComponent.value != 0)
{
//рендер
if (renderSlider.value != 0)
{
image.texture = RenderManager.GetTexture(number, (int)renderSlider.value, newTextureList, renderingDropdownComponent.value);
}
}
else
{
image.texture = newTextureList[number];
//обычная текстура
}
imageSlider.value = number + 1;
//image.texture = texture;
}
public ShadowMapRenderer(Environment environment, int[] size, float[] splits, RenderManager rm, Camera viewcam, float splitDistance)
{
this.rm = rm;
this.environment = environment;
this.v_cam = viewcam;
this.splitDist = splitDistance;
Vector3f ld = environment.DirectionalLight.Direction.Normalize();
this.lightDirection = new Vector3f(-ld.x, -ld.y, -ld.z);
this.splits = splits;
this.shadowMapWidth = size[0];
this.shadowMapHeight = size[1];
for (int i = 0; i < 8; i++)
{
frustumCornersLS[i] = new Vector3f();
frustumCornersWS[i] = new Vector3f();
}
}
public override void Apply()
{
var graphic = GraphicDeviceFactory.Device;
var ps = graphic.PS;
ps.SetResource(8, null);
//render to shadow factor texture
RenderManager.ApplyTechnique(_silluteRender);
#region render to edgeTexture
var edgeTexture = _silluteRender.ShadowFatorTex;
_downSampledRts[0].SetTarget(graphic);
edgeTexture.SetTexture(0, graphic);
_effect.Technique = 1;
ps.SetSampler(0, SamplerState.Point);
_sprite.Begin();
_sprite.SetFullScreenTransform(_input);
_sprite.DrawQuad(_effect);
_sprite.End();
#endregion
#region DownSampling
ps.SetSampler(0, SamplerState.Point);
_effect.Technique = 2;
_sprite.Begin();
for (int i = 0; i < _downSampledRts.Length - 1; i++)
{
DownSample(graphic, _downSampledRts[i], _downSampledRts[i + 1]);
ps.SetResource(0, null);
}
_sprite.End();
_effect.Technique = 0;
graphic.RestoreRenderTarget();
#endregion
base.Apply();
}
public void ChangeImageRender()
{
if (imageSlider.value != 0)
{
if (renderingDropdownComponent.value != 0 && renderSlider.value != 0)
{
if (mergingImagesNumber != null)
{
mergingImagesNumber.text = renderSlider.value.ToString();
}
image.texture = RenderManager.GetTexture((int)imageSlider.value - 1, (int)renderSlider.value, textureList, renderingDropdownComponent.value);
}
else
{
image.texture = textureList[(int)imageSlider.value - 1];
}
}
}
public ShadowMapRenderer(Environment environment, int[] size, float[] splits, RenderManager rm, Camera viewcam, float splitDistance)
{
this.rm = rm;
this.environment = environment;
this.v_cam = viewcam;
this.splitDist = splitDistance;
Vector3f ld = environment.DirectionalLight.Direction.Normalize();
this.lightDirection = new Vector3f(-ld.x, -ld.y, -ld.z);
this.splits = splits;
this.shadowMapWidth = size[0];
this.shadowMapHeight = size[1];
for (int i = 0; i < 8; i++)
{
frustumCornersLS[i] = new Vector3f();
frustumCornersWS[i] = new Vector3f();
}
}
protected override void Initialize()
{
GameState = GameStates.MainMenu;
AppStateManager = new AppStateManager(this);
RenderManager = new RenderManager(Content, Graphics.GraphicsDevice);
InputManager = new InputManager(this);
MenuManager = new MenuManager(RenderManager.GuiNode, InputManager, this);
AppStateManager.Attach(InputManager);
AppStateManager.Attach(MenuManager);
Graphics.PreparingDeviceSettings += (object s, PreparingDeviceSettingsEventArgs args) =>
{
args.GraphicsDeviceInformation.PresentationParameters.RenderTargetUsage = RenderTargetUsage.PreserveContents;
};
Graphics.ApplyChanges();
base.Initialize();
}
public VentanaJuego()
{
InitializeComponent();
//this.Width = w;
//this.Height = h;
//pictureBox1.Width = w ;
//pictureBox1.Height = h;
//----------Manager--------------------//
F_M = new FileManager();
R_M = new RenderManager();
S_M = new SceneManager();
PM = new PhisicManager();
//--------Delegados-------------------//
S_H = new SceneHandler(S_M.PlayScene);
R_H = new RenderHandler(R_M.AddData);
F_H = new FileHandler(F_M.GetImg);
//---------Inicializacion------------//
R_M.AddHandlers(S_H, F_H);
//mapa1.SetFileManager(F_H);
mapa1 = F_M.CargarMapa("../../Mapas/mapa3.xml", this.Width, this.Height, 32);
mapa1.IM.left = Keys.A;
mapa1.IM.right = Keys.D;
mapa1.IM.up = Keys.W;
mapa1.IM.down = Keys.S;
mapa1.Draw(R_H);
R_M.Sorting();
//--------Timer--------------------//
//Thread mov = new Thread(Caminar);
//Thread col = new Thread(Colicion);
//mov.Start();
timer1.Start();
//col.Start();
mapa1.FraccPantalla(pictureBox1.Width, pictureBox1.Height);
mapa1.CentrarJugador();
//----------Sonido------------------//
//mp = new MP3Player();
//mp.Open(F_M.GetAud_Path("Correr"));
//mp.Play();
pictureBox1.Refresh();
}
/// <summary>
/// Closes all managers, and re-inits them
/// </summary>
public virtual void reset()
{
close();
Rand.Instance.reSeed();
InputSourceManager.getSource().init();
RenderManager.init(GraphicsDevice);
ObjectManager.init();
ResourceManager.init(Content);
InputManager.init();
LogManager.init();
//RUN THE START CODE
if (CurrentScene != null)
{
GameLevel lvl = loadLevel(CurrentScene);
}
}
public XNABufferPair(
RenderManager renderManager, int id,
int vertexCount, int indexCount
)
{
if (renderManager == null)
{
throw new ArgumentNullException("renderManager");
}
if (vertexCount >= UInt16.MaxValue)
{
throw new ArgumentOutOfRangeException("vertexCount", vertexCount, "Vertex count must be less than UInt16.MaxValue");
}
Id = id;
RenderManager = renderManager;
VertexCount = vertexCount;
IndexCount = indexCount;
}
//, AddElemento ae)
public MakeMap(FileHandler fh, List<Elemento> herr, CreateMap cm)
{
InitializeComponent();
//
Matriz = new List<Elemento>();
temMap = new Map("", 0, 0, (int)width.Value, (int)height.Value, trackBar1.Maximum);
S_M = new SceneManager();
R_M = new RenderManager();
R_M.AddHandlers(new SceneHandler(S_M.PlayScene), fh);
F_H = fh;
temMap.SetFileManager(fh);
CrearMatriz((int)height.Value,(int)width.Value,trackBar1.Value,1);
temMap.Draw(new RenderHandler(R_M.AddData));
R_M.Fondo = Color.White;
temp = new List<Elemento>();
Herramienta = herr;
pm = new PhisicManager();
C_M = cm;
}
//[Serializable]
//class Activator : IResourceActivator
//{
// AssetReference _package;
// string _name;
// private AssetReference _physics;
// public void Initialize(IAssetProvider provider)
// {
// Scene scene = (Scene)provider;
// AssetContext.SetGlobal<Scene>(scene);
// _name = scene.Name;
// //descrip = new SceneDescription
// //{
// // Name = scene.name,
// // CreateRootNode = false,
// // QuadTreeMaxSize = scene.quadTree.BoundRect.Width,
// // QuadTreeMinSize = scene.quadTree.BoundRect.Width / (float)Math.Pow(2, scene.quadTree.MaxLevel)
// //};
// ContentPackage pk = AssetContext.GetGlobal<ContentPackage>();
// bool removePk = false;
// if (pk == null)
// {
// pk = new ContentPackage(scene._name);
// AssetContext.SetGlobal<ContentPackage>(pk);
// removePk = true;
// }
// scene.AddToPackage(pk);
// if (scene._physics != null)
// {
// _physics = AssetManager.Instance.GetAssetReference(scene._physics);
// AssetContext.SetGlobal<Physic>(scene._physics);
// //scene.physScene.AddToPackage(pk);
// }
// _package = AssetManager.Instance.GetAssetReference(pk);
// if (removePk)
// {
// AssetContext.SetGlobal<ContentPackage>(null);
// }
// }
// public IAssetProvider OnCreateResource()
// {
// Scene scene = new Scene();
// AssetContext.SetGlobal<Scene>(scene);
// if (_physics != null)
// {
// scene.Physics = (Physic)AssetManager.Instance.GetAssetProvider(_physics);
// AssetContext.SetGlobal<Physic>(scene._physics);
// }
// ContentPackage pk = (ContentPackage)AssetManager.Instance.GetAssetProvider(_package);
// AssetContext.SetGlobal<Scene>(null);
// AssetContext.SetGlobal<Physic>(null);
// scene.Nodes.AddRange(pk.Providers.FindAll(x => (x is SceneNode) && ((SceneNode)x).Parent == null).Cast<SceneNode>());
// return scene;
// }
//}
public virtual void Draw()
{
RenderManager.ApplyTechnique();
if (_physics != null && _physics.Visible)
{
var tech = Service.Require <PhysicDisplayTechnique>();
tech.Apply();
}
foreach (var item in Drawables)
{
item.Draw();
}
foreach (var entry in GetDecalGraphics())
{
entry.Draw(PixelClipping.None);
}
}
// Get a DisplayConfig object from the server via ClientKit.
// Setup stereo rendering with DisplayConfig data.
void SetupDisplay()
{
//get the DisplayConfig object from ClientKit
if (_clientKit == null || _clientKit.context == null)
{
if (!_osvrClientKitError)
{
Debug.LogError("[OSVR-Unity] ClientContext is null. Can't setup display.");
_osvrClientKitError = true;
}
return;
}
_displayConfig = _clientKit.context.GetDisplayConfig();
if (_displayConfig == null)
{
return;
}
_displayConfigInitialized = true;
SetupRenderManager();
//get the number of viewers, bail if there isn't exactly one viewer for now
_viewerCount = _displayConfig.GetNumViewers();
if (_viewerCount != 1)
{
Debug.LogError("[OSVR-Unity] " + _viewerCount + " viewers found, but this implementation requires exactly one viewer.");
return;
}
//Set Unity player resolution
SetResolution();
//create scene objects
CreateHeadAndEyes();
//create RenderBuffers in RenderManager
if (UseRenderManager && RenderManager != null)
{
RenderManager.ConstructBuffers();
}
SetRenderParams();
}
public void InitializeGeometry(RenderManager RenderManager, SettingsContainer WorldSettings)
{
TerrainGeometry = new Geometry3D(Name);
TerrainGeometry.Shader = RenderManager.Shaders["Terrain"].Clone();
TerrainGeometry.DepthShader = RenderManager.Shaders["Depth-Terrain"].Clone();
TerrainGeometry.Shader.Parameters["TextureSize"].SetValue(1.0f / WorldSettings.TextureSize);
TerrainGeometry.DepthShader.Parameters["TerrainScale"].SetValue(WorldFile.TerrainScale);
TerrainGeometry.Shader.Parameters["TerrainScale"].SetValue(WorldFile.TerrainScale);
TerrainGeometry.Shader.Parameters["TerrainWidth"].SetValue(WorldFile.SX);
TerrainGeometry.Shader.Parameters["TerrainHeight"].SetValue(WorldFile.SY);
TerrainGeometry.DepthShader.Parameters["TerrainWidth"].SetValue(WorldFile.SX);
TerrainGeometry.DepthShader.Parameters["TerrainHeight"].SetValue(WorldFile.SY);
TerrainGeometry.Shader.Parameters["MaterialWidth"].SetValue(WorldFile.MaterialMap.GetLength(0));
TerrainGeometry.Shader.Parameters["MaterialHeight"].SetValue(WorldFile.MaterialMap.GetLength(1));
TerrainGeometry.Shader.Parameters["DiffuseMap"].SetValue(RenderManager.Textures["Terrain-Diffuse"]);
TerrainGeometry.Shader.Parameters["RoughnessMap"].SetValue(RenderManager.Textures["Terrain-Roughness"]);
TerrainGeometry.Shader.Parameters["MaterialNormalMap"].SetValue(RenderManager.Textures["Terrain-Normal"]);
TerrainGeometry.Shader.Parameters["MetalnessMap"].SetValue(RenderManager.Textures["Terrain-Metalness"]);
TerrainGeometry.Shader.Parameters["DecalDiffuseMap"].SetValue(RenderManager.Textures["TerrainDecal-Diffuse"]);
TerrainGeometry.Shader.Parameters["DecalMetalnessMap"].SetValue(RenderManager.Textures["TerrainDecal-Roughness"]);
TerrainGeometry.Shader.Parameters["DecalNormalMap"].SetValue(RenderManager.Textures["TerrainDecal-Normal"]);
TerrainGeometry.Shader.Parameters["DecalRoughnessMap"].SetValue(RenderManager.Textures["TerrainDecal-Roughness"]);
TerrainGeometry.Shader.Parameters["DecalToleranceMap"].SetValue(RenderManager.Textures["TerrainDecal-Tolerance"]);
Vector3 ChunkPosition = new Vector3(WorldFile.IDX * WorldFile.SX * WorldFile.TerrainScale, WorldFile.IDY * WorldFile.SY * WorldFile.TerrainScale, 0);
TerrainGeometry.Shader.Parameters["Position"].SetValue(ChunkPosition);
TerrainGeometry.DepthShader.Parameters["Position"].SetValue(ChunkPosition);
TerrainGeometry.HasCull = false;
TerrainGeometry.Position = WorldFile.GetPosition();
TerrainGeometry.RenderBucket = Geometry3D.RenderQueue.Solid;
TerrainGeometry.CurrentRenderMode = Geometry3D.RenderMode.NonIndexBufferless;
TerrainGeometry.VertexCount = (WorldFile.HeightMap.GetLength(0) - 1) * (WorldFile.HeightMap.GetLength(1) - 1) * 6;
}
public GUIManager(Game game)
{
this.inputManager = game.InputManager;
this.renderManager = game.RenderManager;
this.spriteRenderer = game.RenderManager.SpriteRenderer;
game.RootNode.AddChild(guiNode);
inputManager.AddMouseEvent(new MouseEvent(InputManager.MouseButton.Left, false, () =>
{
for (int i = 0; i < controls.Count; i++)
{
if (controls[i] is Clickable)
{
if (Collides(controls[i], inputManager.GetMouseX() + inputManager.SCREEN_WIDTH / 2, inputManager.GetMouseY() + inputManager.SCREEN_HEIGHT / 2))
{
controls[i].hasFocus = true;
((Clickable)controls[i]).LeftClicked();
controls[i].clicked = true;
}
else
{
controls[i].hasFocus = false;
}
}
}
}));
inputManager.AddMouseEvent(new MouseEvent(InputManager.MouseButton.Left, true, () =>
{
for (int i = controls.Count - 1; i > -1; i--)
{
if (i < controls.Count)
{
if (controls[i].clicked == true)
{
((Clickable)controls[i]).LetGo();
controls[i].clicked = false;
}
}
}
}));
}
protected override void CreateScene()
{
var pointList = new List <CameraPoint>()
{
new CameraPoint()
{
Position = new Vector3(0f, 0f, 15f), LookAt = Vector3.Zero, Up = Vector3.Up
},
new CameraPoint()
{
Position = new Vector3(30f, 0f, 15f), LookAt = Vector3.Zero, Up = Vector3.Up
},
new CameraPoint()
{
Position = new Vector3(30f, 30f, 15f), LookAt = new Vector3(-15f, 0f, 0f), Up = Vector3.UnitX
},
new CameraPoint()
{
Position = new Vector3(-30f, 0f, 15f), LookAt = new Vector3(-15f, 0f, 0f), Up = Vector3.Up
},
new CameraPoint()
{
Position = new Vector3(0f, 0f, 15f), LookAt = Vector3.Zero, Up = Vector3.Up
}
};
PathCamera pathCamera = new PathCamera("path", new Vector3(0, 15f, 15f), Vector3.Zero, pointList, 500)
{
Speed = 0.5f,
};
RenderManager.SetActiveCamera(pathCamera.Entity);
EntityManager.Add(pathCamera.Entity);
CreateCube("Cube1", Vector3.Zero);
CreateCube("Cube2", new Vector3(15f, 0f, 0f));
CreateCube("Cube3", new Vector3(-15f, 0f, 0f));
CreateCube("Cube4", new Vector3(0f, 0f, 15f));
CreateCube("Cube5", new Vector3(0f, 0f, -15f));
RenderManager.BackgroundColor = Color.CornflowerBlue;
}
public virtual void draw(RenderManager manager, GameTime time)
{
var area = this.List.Area;
var srcRect = new Rectangle(0, 0, area.Width, area.Height);
var drawArea = new Rectangle(area.X - 5, area.Y - 5, area.Width + 10, area.Height + 10);
manager.Batch.Draw(GraphicsHelper.TranslucentWhite, drawArea, srcRect, Color.Black);
foreach (var component in this.List.Components)
{
if (component.IsVisible)
{
var renderer = component.getRenderer();
if (renderer != null)
{
renderer.draw(manager, time);
}
}
}
}
public TerrainGeometryContainer(RenderManager RenderManager, SettingsContainer WorldSettings, WorldFile File)
{
WorldFile = File;
Name = "Terrain: " + File.FileName;
InitializeGeometry(RenderManager, WorldSettings);
MaterialData0 = new Texture2D(RenderManager.Graphics, WorldFile.MaterialMap.GetLength(0), File.MaterialMap.GetLength(1));
MaterialData1 = new Texture2D(RenderManager.Graphics, WorldFile.MaterialMap.GetLength(0), File.MaterialMap.GetLength(1));
HeightMap = new Texture2D(RenderManager.Graphics, WorldFile.SX + 1, WorldFile.SY + 1, false, SurfaceFormat.Color);
//GenerateNormals = new TextureTask(Name + "-GenerateNormals",TaskType.GenerateNormals, TaskStage.PreRenderTarget, TaskUsage.FrameLimit, TaskSwitchType.Ping);
//GenerateNormals.AddParameter(TextureParameter.InputTexture, HeightMap);
//GenerateNormals.AddParameter(FloatParameter.TextureWidth0, WorldFile.SX + 1);
//GenerateNormals.AddParameter(FloatParameter.TextureHeight0, WorldFile.SY + 1);
//GenerateNormals.SetRenderTarget(NormalMap);
//GenerateNormals.AttachOutPut("NormalMap", TerrainGeometry.Shader);
//RenderManager.AddTextureModificationTask(GenerateNormals);
}
public DrawerInterpretor()
: base()
{
_RenderManager = Object.FindObjectOfType <RenderManager>();
_savedPositions = new Stack <DrawState>();
AddAction('+', false, IncreaseAngle);
AddAction('-', false, DecreaseAngle);
AddAction('Y', true, DrawLine); // TODO add a way to add multiple sign doing the same action
AddAction('G', true, DrawLine);
AddAction('F', true, DrawLine);
AddAction('E', true, DrawLine);
AddAction('C', false, DrawCircle);
AddAction('f', true, Move);
AddAction('[', false, SaveDrawState);
AddAction(']', false, RestoreDrawState);
AddAction('>', false, MultiplyLineLength);
AddAction('<', false, DivideLineLength);
Reset();
}
/// <summary>
/// Creates the scene.
/// </summary>
/// <remarks>
/// This method is called before all <see cref="T:WaveEngine.Framework.Entity" /> instances in this instance are initialized.
/// </remarks>
protected override void CreateScene()
{
RenderManager.BackgroundColor = Color.Black;
RenderManager.DebugLines = false;
RenderManager.RegisterLayerBefore(new SkyLayer(this.RenderManager), DefaultLayers.Alpha);
FreeCamera camera = new FreeCamera("camera", new Vector3(-2.4f, 0, -3), new Vector3(-1.6f, 0, -2.5f))
{
Speed = 2,
NearPlane = 0.1f
};
EntityManager.Add(camera.Entity);
RenderManager.SetActiveCamera(camera.Entity);
this.CreateSunFlare();
this.CreatePlanet("Earth", Vector3.Zero, 1, 10, Vector3.Zero, 0);
this.CreatePlanet("Moon", new Vector3(0, 0, 20), 1, 28, Vector3.Zero, 28);
}
protected override void Render()
{
var graphics = GraphicDeviceFactory.Device;
var scene = Engine.Scene;
//swapChain.MakeCurrent();
graphics.SetRenderTarget(_swapChain.BackBuffer, _depthBuffer);
graphics.ViewPort = _viewport;
graphics.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Engine.BackColor, 1, 0);
OnRenderBegin();
if (scene != null)
{
RenderManager.ApplyTechnique();
}
OnRender();
_swapChain.Present();
}
public static void Render(RenderManager.CameraInfo cameraInfo, GuideLine guideLine)
{
var renderManager = RenderManager.instance;
var minHeight = -1f;
var maxHeight = 1280f;
var direction = guideLine.Origin.Flatten().DirectionTo(guideLine.Intersect.Flatten());
var line = new Segment3(guideLine.Origin, guideLine.Origin + direction*100000f);
renderManager.OverlayEffect.DrawSegment(cameraInfo, Settings.SecondaryColor,
line, guideLine.Width, 0,
minHeight,
maxHeight, true, true);
renderManager.OverlayEffect.DrawSegment(cameraInfo, Settings.SecondaryColor,
line, 0.01f, 8f,
minHeight,
maxHeight, true, true);
}
internal static void TryRegister(GameObject gameObj)
{
if (gameObj.get_isStatic())
{
return;
}
Renderer component = gameObj.GetComponent <Renderer>();
if (component == null || component.get_sharedMaterials() == null || component.get_isPartOfStaticBatch())
{
return;
}
if (!component.get_enabled() || !RenderManager.FindValidTag(component.get_sharedMaterials()))
{
return;
}
if (component.GetType() == typeof(MeshRenderer) || component.GetType() == typeof(SkinnedMeshRenderer))
{
gameObj.AddMissingComponent <RenderCompoent>();
}
}
public Graph(MainWindow window)
{
myGui = window;
renderManager = new RenderManager();
control = new TriangleNet.Rendering.GDI.RenderControl();
Options = new ConstraintOptions();
Options.ConformingDelaunay = false;
Options.SegmentSplitting = 0;
if (control != null)
{
InitializeRenderControl((Control)control);
renderManager.Initialize(control);
control.Refresh();
}
else
{
MessageBox.Show("Error", "Failed to initialize renderer.");
}
}
protected override void CreateScene()
{
RenderManager.BackgroundColor = Color.CornflowerBlue;
ViewCamera camera = new ViewCamera("MainCamera", new Vector3(2, 1, 2), new Vector3(0, 1, 0));
EntityManager.Add(camera.Entity);
RenderManager.SetActiveCamera(camera.Entity);
Entity animatedModel = new Entity("Isis")
.AddComponent(new Transform3D())
.AddComponent(new BoxCollider())
.AddComponent(new SkinnedModel("Content/isis.wpk"))
.AddComponent(new MaterialsMap(new BasicMaterial("Content/isis-difuse.wpk")))
.AddComponent(new Animation3D("Content/isis-animations.wpk"))
.AddComponent(new SkinnedModelRenderer());
anim = animatedModel.FindComponent <Animation3D>();
EntityManager.Add(animatedModel);
}
protected override void EndOverlayImpl(RenderManager.CameraInfo cameraInfo)
{
base.EndOverlayImpl(cameraInfo);
if (!m_active)
{
return;
}
float l_dimension = m_defaultDimension + m_dimensionDelta;
RenderManager renderManager = RenderManager.instance;
Quad3 position = new Quad3(
new Vector3(-l_dimension + m_translation.x, 0, -l_dimension + m_translation.y),
new Vector3(l_dimension + m_translation.x, 0, -l_dimension + m_translation.y),
new Vector3(l_dimension + m_translation.x, 0, l_dimension + m_translation.y),
new Vector3(-l_dimension + m_translation.x, 0, l_dimension + m_translation.y)
);
renderManager.OverlayEffect.DrawQuad(cameraInfo, m_lastTexture, Color.white, position, -1f, 1800f, false, true);
}
/// <summary>
/// Create Scene
/// </summary>
protected override void CreateScene()
{
RenderManager.BackgroundColor = Color.CornflowerBlue;
RenderManager.DebugLines = true;
// Createa a Free Camera (W, A, S, D Keyboard controlled)
FreeCamera camera = new FreeCamera("MainCamera", new Vector3(0, 5, 5), Vector3.Zero);
EntityManager.Add(camera.Entity);
RenderManager.SetActiveCamera(camera.Entity);
// We set group before entities grouping
this.groupA = new Physic3DCollisionGroup();
this.groupB = new Physic3DCollisionGroup();
// GroupA RED will Ignore Self Group Collision
this.groupA.IgnoreCollisionWith(this.groupA);
// GroupA RED will Ignore GroupB BLUE Collision
this.groupA.IgnoreCollisionWith(this.groupB);
// GroupB BLUE will Collide Self group entities.
// Every entity collide all groups by default for each new Collision group.
// Use Physic3DCollisionGroup.DefaulCollisionGroup Property to get Engine Physic3D default Collision group
// Creates a plane ground
this.CreateGround();
// Creates Blue-Blue enviroment
this.CreateSphere(new Vector3(-2, 0, -3), true);
this.CreateSphere(new Vector3(2, 0, -3), true);
// Creates Blue-Red enviroment
this.CreateSphere(new Vector3(-2, 0, -1), true);
this.CreateSphere(new Vector3(2, 0, -1), false);
// Creates Red-Red enviroment
this.CreateSphere(new Vector3(-2, 0, 1), false);
this.CreateSphere(new Vector3(2, 0, 1), false);
}
private static void StaticReset(int frameIndex, RenderManager renderManager)
{
if (_LastFrameStaticReset >= frameIndex)
{
return;
}
// Any buffers that remain unused (either from being too small, or being unnecessary now)
// should be disposed.
XNABufferPair <TVertex> hb;
using (var e = _UnusedHardwareBuffers.GetEnumerator())
while (e.GetNext(out hb))
{
hb.Age += 1;
int usedCount = hb.IsLarge ? _LargeUnusedBufferCount : _SmallUnusedBufferCount;
int usedLimit = hb.IsLarge ? MaxLargeUnusedBuffers : MaxSmallUnusedBuffers;
bool shouldKill = (!hb.ProtectedFromDeath && (hb.Age >= MaxBufferAge)) ||
((usedCount > usedLimit) && (hb.Age > 1));
if (shouldKill)
{
e.RemoveCurrent();
hb.Invalidate(frameIndex);
if (hb.IsLarge)
{
_LargeUnusedBufferCount--;
}
else
{
_SmallUnusedBufferCount--;
}
renderManager.DisposeResource(hb);
}
}
_LastFrameStaticReset = frameIndex;
}
protected void Awake()
{
if (assetLibrary == null)
{
Debug.LogError($"[{nameof(DemoController)}] No '{nameof(GraphicAssetLibrary)}' provided!");
return;
}
//Create utilities
logger = new Utils.Logger(UnityEngine.Debug.Log);
subtaskRunner = new SubtaskRunner(executorCount);
entityContext = new EntityContext();
deltaTime = new DeltaTimeHandle();
random = new ShiftRandomProvider();
renderManager = new RenderManager(executorCount, assetLibrary);
colliderManager = new ColliderManager(new AABox(minCollisionArea, maxCollisionArea));
//Create systems
systemManager = new TaskManager(subtaskRunner, new ECS.Tasks.ITask[]
{
new ApplyVelocitySystem(deltaTime, entityContext),
new RegisterColliderSystem(colliderManager, entityContext),
new TestCollisionSystem(deltaTime, colliderManager, entityContext),
new ApplyGravitySystem(deltaTime, entityContext),
new SpawnProjectilesSystem(colliderManager, deltaTime, entityContext),
new SpawnTurretSystem(new AABox(minTurretSpawnArea, maxTurretSpawnArea), turretCount, random, entityContext),
new SpawnSpaceshipSystem(new AABox(minSpaceshipSpawnArea, maxSpaceshipSpawnArea), spaceshipCount, random, entityContext),
new ExplodeSpaceshipWhenCrashSystem(entityContext),
new DisableSpaceshipWhenHitSystem(entityContext),
new AgeSystem(deltaTime, entityContext),
new LifetimeSystem(entityContext),
new RegisterRenderObjectsSystem(renderManager, entityContext),
}, logger, timeline);
timeline?.StartTimers();
}
protected override void CreateScene()
{
var random = WaveServices.Random;
var freeCamera = new FreeCamera("FreeCamera", new Vector3(0, 10, -10), Vector3.Zero)
{
FarPlane = 100
};
freeCamera.BackgroundColor = Color.CornflowerBlue;
freeCamera.Entity.AddComponent(new CameraFrustum());
EntityManager.Add(freeCamera);
var fixedCamera = new FixedCamera("FixedCamera", new Vector3(20, 50, -20), new Vector3(20, 0, 20));
fixedCamera.Entity.FindComponent <Camera3D>().Viewport = new Viewport(0, 0.6f, 0.4f, 0.4f);
fixedCamera.ClearFlags = ClearFlags.DepthAndStencil;
EntityManager.Add(fixedCamera);
RenderManager.SetFrustumCullingCamera(freeCamera.Entity);
int num = 15;
for (int i = 0; i < num; i++)
{
for (int j = 0; j < num; j++)
{
if (random.NextBool())
{
Entity cube = CreateCube("Cube" + (j + (i * num)), new Vector3(j * 3, 0, i * 3));
EntityManager.Add(cube);
}
else
{
Entity sphere = CreateSphere("Sphere" + (j + (i * num)), new Vector3(j * 3, 0, i * 3));
EntityManager.Add(sphere);
}
}
}
}
private static void UpdateRender(Bounds bounds)
{
int num1 = Mathf.Clamp((int)(bounds.min.x / 64f + 135f), 0, 269);
int num2 = Mathf.Clamp((int)(bounds.min.z / 64f + 135f), 0, 269);
int x0 = num1 * 45 / 270 - 1;
int z0 = num2 * 45 / 270 - 1;
num1 = Mathf.Clamp((int)(bounds.max.x / 64f + 135f), 0, 269);
num2 = Mathf.Clamp((int)(bounds.max.z / 64f + 135f), 0, 269);
int x1 = num1 * 45 / 270 + 1;
int z1 = num2 * 45 / 270 + 1;
RenderManager renderManager = Singleton <RenderManager> .instance;
RenderGroup[] renderGroups = renderManager.m_groups;
for (int i = z0; i < z1; i++)
{
for (int j = x0; j < x1; j++)
{
int n = Mathf.Clamp(i * 45 + j, 0, renderGroups.Length - 1);
if (n < 0)
{
continue;
}
else if (n >= renderGroups.Length)
{
break;
}
if (renderGroups[n] != null)
{
renderGroups[n].SetAllLayersDirty();
renderManager.m_updatedGroups1[n >> 6] |= 1uL << n;
renderManager.m_groupsUpdated1 = true;
}
}
}
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
public virtual void Initialize(
GameController controller,
ContentManager content,
GraphicsDevice graphicsDevice,
InputManager inputMan,
InputSourceManager inputSourceMan,
LogManager logger,
ObjectManager objectMan,
RenderManager renderMan,
ResourceManager resourceMan
)
{
//set the basic components
GraphicsDevice = graphicsDevice;
Content = content;
GameController = controller;
//close any previous managers
close();
//assign new managers
InputManager = inputMan;
InputSourceManager = inputSourceMan;
LogManager = logger;
ObjectManager = objectMan;
ResourceManager = resourceMan;
RenderManager = renderMan;
HudManager = HudManager.Instance;
//initialize
ResourceManager.init(content);
RenderManager.init(graphicsDevice);
ObjectManager.init();
InputManager.init();
LogManager.init();
HudManager.init();
}
// Updates the position and rotation of the head
// Optionally, update the viewer associated with this head
public void UpdateHeadPose()
{
OSVR.ClientKit.Pose3 eyePose0 = RenderManager.GetRenderManagerEyePose((byte)0);
OSVR.ClientKit.Pose3 eyePose1 = RenderManager.GetRenderManagerEyePose((byte)1);
// Convert from OSVR space into Unity space.
Vector3 pos0 = OSVR.Unity.Math.ConvertPosition(eyePose0.translation);
Quaternion rot0 = OSVR.Unity.Math.ConvertOrientation(eyePose0.rotation);
Vector3 pos1 = OSVR.Unity.Math.ConvertPosition(eyePose1.translation);
Quaternion rot1 = OSVR.Unity.Math.ConvertOrientation(eyePose1.rotation);
Quaternion slerpedRot = Quaternion.Slerp(rot0, rot1, 0.5f);
Vector3 pos = new Vector3((pos0.x + pos1.x) * 0.5f, (pos0.y + pos1.y) * 0.5f, (pos0.z + pos1.z) * 0.5f);
// Invert the transformation
_camera0CachedTransform.localRotation = Quaternion.Inverse(slerpedRot);
Vector3 invPos = -pos;
_camera0CachedTransform.localPosition = Quaternion.Inverse(slerpedRot) * invPos;
}
void Awake()
{
renderManager = Singleton<RenderManager>.instance;
buildingManager = Singleton<BuildingManager>.instance;
var cameraController = FindObjectOfType<CameraController>();
mainCamera = cameraController.GetComponent<Camera>();
var mat = new Material(Shaders.buildingReplacementV2);
buildingWindowsReplacement = mat.shader;
buildingsGlowPP = new Material(Shaders.buildingGlowPPv5);
glowBlurPP = new Material(Shaders.glowBlurPP);
int w = Camera.main.pixelWidth/blurDownscale;
int h = Camera.main.pixelHeight/blurDownscale;
rt = new RenderTexture(w, h, 24, RenderTextureFormat.Default, RenderTextureReadWrite.Linear);
rtBlurH = new RenderTexture(w, h, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Linear);
rtBlurV = new RenderTexture(w, h, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Linear);
dummyGO = new GameObject();
dummyCamera = dummyGO.AddComponent<Camera>();
dummyCamera.enabled = false;
buildingsCullingMask = 1 << LayerMask.NameToLayer("Buildings");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Props");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Terrain");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Decoration");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Trees");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Vehicles");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Citizens");
occludersCullingMask |= 1 << LayerMask.NameToLayer("PowerLines");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Road");
renderManagerLateUpdate = typeof(RenderManager).GetMethod("LateUpdate", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
}
public override void RenderEffect(InstanceID id, EffectInfo.SpawnArea area, Vector3 velocity, float acceleration, float magnitude, float timeDelta, RenderManager.CameraInfo cameraInfo)
{
var pos = area.m_matrix.MultiplyPoint(Vector3.zero);
if ((pos - Camera.main.transform.position).sqrMagnitude > 1000.0f)
{
return;
}
var dir = area.m_matrix.MultiplyVector(Vector3.forward);
// Log.Warning(dir.ToString());
pos += Vector3.up * 8.0f;
pos += dir*5.0f;
id.Index = (uint)UnityEngine.Random.Range(0, 256);
LightData data = new LightData(id, pos, new Color(1.0f, 0.827f, 0.471f), 0.6f, 32.0f, 10.0f);
data.m_type = LightType.Spot;
data.m_spotAngle = 60.0f;
data.m_rotation = Quaternion.Euler(90, 0, 0);
Singleton<RenderManager>.instance.DrawLight(data);
}
private void _renderOverlayTimedSelectNodes(RenderManager.CameraInfo cameraInfo)
{
if (_hoveredNetNodeIdx != 0 && !ContainsListNode(_hoveredNetNodeIdx) && !m_toolController.IsInsideUI && Cursor.visible)
{
var node = GetNetNode(_hoveredNetNodeIdx);
var segment = Singleton<NetManager>.instance.m_segments.m_buffer[node.m_segment0];
if ((node.m_flags & NetNode.Flags.TrafficLights) != NetNode.Flags.None)
{
Bezier3 bezier;
bezier.a = node.m_position;
bezier.d = node.m_position;
var color = GetToolColor(false, false);
NetSegment.CalculateMiddlePoints(bezier.a, segment.m_startDirection, bezier.d,
segment.m_endDirection, false, false, out bezier.b, out bezier.c);
_renderOverlayDraw(cameraInfo, bezier, color);
}
}
if (SelectedNodeIndexes.Count <= 0) return;
foreach (var index in SelectedNodeIndexes)
{
var node = GetNetNode(index);
var segment = Singleton<NetManager>.instance.m_segments.m_buffer[node.m_segment0];
Bezier3 bezier;
bezier.a = node.m_position;
bezier.d = node.m_position;
var color = GetToolColor(true, false);
NetSegment.CalculateMiddlePoints(bezier.a, segment.m_startDirection, bezier.d,
segment.m_endDirection, false, false, out bezier.b, out bezier.c);
_renderOverlayDraw(cameraInfo, bezier, color);
}
}
