protected override void Render(ScriptableRenderContext context, Camera[] cameras) { BeginFrameRendering(context, cameras); foreach (var RenderCamera in cameras) { #if UNITY_EDITOR //seting UI in SceneEdit bool isSceneViewCam = RenderCamera.cameraType == CameraType.SceneView; if (isSceneViewCam) { ScriptableRenderContext.EmitWorldGeometryForSceneView(RenderCamera); } #endif //////Set Camera Property BeginCameraRendering(context, RenderCamera); context.SetupCameraProperties(RenderCamera); /////Cull Object ScriptableCullingParameters cullingParameters; if (!RenderCamera.TryGetCullingParameters(out cullingParameters)) { continue; } CullingResults CullingData = context.Cull(ref cullingParameters); //Drwa PipeLine Pass RenderingContent(isSceneViewCam, RenderCamera, CullingData, context); ///Submit RenderContent context.Submit(); EndCameraRendering(context, RenderCamera); } }
/// <summary> /// this should be used for rendering/drawing. /// </summary> /// <param name="transform"></param> /// <param name="camera"></param> public void LoadTransform(out Transform transform, ref RenderCamera camera) { trs.LoadTransform(out transform); if (isBillboard) { camera.MakeBillboard(ref transform); } }
public RenderUnit(RenderCamera owner, RenderCompoent obj) { this.m_error = false; this.m_initialized = false; this.m_owner = owner; this.m_obj = obj; this.Initialize(); }
internal void RegisterCamera(RenderCamera camera) { Camera component = camera.GetComponent <Camera>(); if ((component.get_cullingMask() & 1 << base.get_gameObject().get_layer()) != 0) { this.m_RenderUnit = new RenderUnit(camera, this); camera.RegisterObject(this); } }
public void SetPositionDirection(Vector3 NewPosition, Vector3 Direction, Vector3 Axis, bool IsOrthogonal) { RenderCamera.Position = NewPosition; if (IsOrthogonal) { RenderCamera.GenerateOrthogonalViewMatrix(RenderCamera.Position, RenderCamera.Position + Direction, Axis); } else { RenderCamera.GenerateLookAtViewMatrix(RenderCamera.Position, RenderCamera.Position + Direction, Axis); } }
private void RenderCubeMap(GraphicsDevice Graphics, Vector3 Position) { List <Geometry3D> RenderTargetGeometries = SceneNode.GetAllGeometries(Position); for (int i = 0; i < CubeDirections.Length; i++) { Graphics.SetRenderTarget(RenderTarget); Graphics.DepthStencilState = DepthStencilState.Default; RenderCamera.GenerateLookAtViewMatrix(RenderCamera.Position, RenderCamera.Position + CubeDirections[i], CubeUpVectors[i]); Matrix CameraProjection = RenderCamera.ProjectionMatrix; Matrix CameraView = RenderCamera.ViewMatrix; Graphics.Clear(Color.CornflowerBlue); for (int j = 0; j < RenderTargetGeometries.Count; j++) { Geometry3D Geom = RenderTargetGeometries[j]; Effect Shader = Geom.Shader; if (Geom.HasCull) { continue; } if (Shader.GetType() == typeof(BasicEffect)) { BasicEffect CastShader = (BasicEffect)Shader; CastShader.Projection = CameraProjection; CastShader.View = CameraView; CastShader.World = Matrix.CreateTranslation(Geom.Position); } else { Geom.Shader.Parameters["WorldViewProjection"].SetValue(CameraView * CameraProjection); } foreach (var pass in Shader.CurrentTechnique.Passes) { pass.Apply(); Graphics.SetVertexBuffer(Geom.VertexBuffer); Graphics.DrawPrimitives(PrimitiveType.TriangleList, 0, Geom.VertexBuffer.VertexCount / 3); } } Graphics.SetRenderTarget(null); Color[] Data = new Color[RenderTarget.Width * RenderTarget.Height]; RenderTarget.GetData(Data); CubeMap.SetData(CubeFaces[i], Data); } HasRendered = true; }
/// <summary> /// Get or create the camera used for m_reflectionMat. /// </summary> Camera GetReflectionCamera(Camera current, int textureSize) { if (!m_reflectionRT || m_reflectionRTSize != textureSize) { if (m_reflectionRT) { DestroyImmediate(m_reflectionRT); } m_reflectionRT = new RenderTexture(textureSize, textureSize, 16); m_reflectionRT.name = "__MirrorReflection" + GetInstanceID() + "for" + current.GetInstanceID(); m_reflectionRT.isPowerOfTwo = true; m_reflectionRT.hideFlags = HideFlags.DontSave; m_reflectionRTSize = textureSize; } Camera cam = null; RenderCamera rc; if (m_cameraDic.TryGetValue(current.GetInstanceID(), out rc)) { cam = rc.ReflectionCamera; } if (null == cam) { GameObject go = new GameObject(); go.name = "ReflectionCamera" + GetInstanceID() + "for" + current.GetInstanceID(); go.hideFlags = HideFlags.DontSave; cam = go.AddComponent <Camera>(); cam.clearFlags = CameraClearFlags.Skybox;//CameraClearFlags.Skybox; cam.backgroundColor = new Color(0, 0, 0, 0); cam.enabled = false; if (rc == null) { rc = new RenderCamera(); rc.ReflectionCamera = cam; m_cameraDic.Add(current.GetInstanceID(), rc); } else { rc.ReflectionCamera = cam; } } Shader.SetGlobalTexture("_ReflectionTex", m_reflectionRT); return(cam); }
public void drawEverything(GraphicsInterface gi, Transform transform, ref RenderCamera camTrs) { if (transform != Transform.Identity) { OpenTK.Graphics.OpenGL.GL.PushMatrix(); transform.GL_Load(); drawEverything(gi, ref camTrs); OpenTK.Graphics.OpenGL.GL.PopMatrix(); } else { drawEverything(gi, ref camTrs); } }
private void createCamera(float y) { RCObj = new GameObject("RenderCamera2"); Camera RenderCamera; RenderTexture renderTexture; RenderCamera = RCObj.AddComponent <Camera>(); RenderCamera.transform.parent = Camera.main.gameObject.transform.parent; RenderCamera.hideFlags = HideFlags.None; renderTexture = new RenderTexture(Screen.width, Screen.height, 0); RenderCamera.CopyFrom(Camera.main); for (int i = 0; i < Camera.main.gameObject.transform.childCount; i++) { Camera.main.gameObject.transform.GetChild(i).gameObject.layer = 31; } RenderCamera.depth = 0; RenderCamera.cullingMask = 1 << 31; RenderCamera.targetTexture = renderTexture; RenderCamera.Render(); RCObj.transform.localPosition = new Vector3(0, y, 0); //RCObj.transform.localRotation = Quaternion.Euler(0, 0, 180); RCObjs.Add(RCObj); /*Camera dlag = RCObj.GetComponent<Camera>(); * Matrix4x4 temp = new Matrix4x4(); * temp.m00 = 1.70064f; * temp.m01 = 0; * temp.m02 = 0; * temp.m03 = 0; * temp.m10 = 0; * temp.m11 = 3.02222f; * temp.m12 = 0; * temp.m13 = 0; * temp.m20 = 0; * temp.m21 = 0; * temp.m22 = -1.00080f; * temp.m23 = -0.40016f; * temp.m30 = 0; * temp.m31 = 0; * temp.m32 = -1; * temp.m33 = 0; * dlag.projectionMatrix = temp;*/ }
public bool draw( GraphicsInterface gi, Transform transform, byte drawLayers, ref RenderCamera camTrs) { GeoNode NodeIter; uint NodeIterPos; for (NodeIterPos = NumImmediate, NodeIter = FirstChild; 0 != NodeIterPos; NodeIter = NodeIter.Sibling, --NodeIterPos) { if (0 == (NodeIter.DrawLayerMask & drawLayers)) { continue; } GL.PushMatrix(); transform.GL_Load(); do { NodeIter.draw(gi, ref transform, drawLayers, ref camTrs); while (0 != --NodeIterPos && 0 == ((NodeIter = NodeIter.Sibling).DrawLayerMask & drawLayers)) { continue; } } while (0 != NodeIterPos); GL.DisableClientState(ArrayCap.ColorArray); GL.DisableClientState(ArrayCap.NormalArray); GL.DisableClientState(ArrayCap.TextureCoordArray); GL.DisableClientState(ArrayCap.VertexArray); GL.PopMatrix(); return(true); } return(false); }
internal void UnregisterCamera(RenderCamera camera) { camera.UnregisterObject(this); }
public void drawEverything(GraphicsInterface gi, ref RenderCamera camTrs) { Object3D obj; Model3D model; Transform transform; List <Object3D> list; int i, ilist; byte modelId; bool selected; if (Globals.renderCollisionMap) { collision.drawCollisionMap(false); } else { AreaModel.drawModel(gi, ref camTrs); } for (i = Objects.Count - 1; i >= 0; --i) { obj = Objects[i]; obj.LoadTransform(out transform, ref camTrs); // Need to slighting increase the model's size, just in-case of overlapping bounding boxes. if ((selected = isObjectSelected(0, i))) { transform.scale *= 1.001f; } if ((modelId = obj.ModelID) != 0) { if (!level.ModelIDs.TryGetValue(modelId, out model)) { continue; } if (Globals.drawObjectModels) { model.drawModel(gi, transform, ref camTrs); } BoundingBox.draw(transform, selected ? Globals.SelectedObjectColor : Globals.ObjectColor, model); } else { BoundingBox.draw(transform, selected ? Globals.SelectedObjectColor : Globals.ObjectColor); } } // macro objects, then special objects. for (selected = false, ilist = 1, list = MacroObjects; ilist != 3; list = SpecialObjects, ++ilist) { for (i = list.Count - 1; i >= 0; --i) { obj = list[i]; if ((modelId = obj.ModelID) != 0) { if (!level.ModelIDs.TryGetValue(modelId, out model)) { continue; } obj.LoadTransform(out transform, ref camTrs); if (Globals.drawObjectModels) { model.drawModel(gi, transform, ref camTrs); } BoundingBox.draw(transform, isObjectSelected(ilist, i) ? Globals.SelectedObjectColor : Globals.MacroObjectColor, model); } else { BoundingBox.draw(obj.transform, isObjectSelected(ilist, i) ? Globals.SelectedObjectColor : Globals.MacroObjectColor); } } } }
protected override void Render(ScriptableRenderContext RenderContext, Camera[] RenderCameras) { //Gather MeshBatch NativeList <FMeshBatch> MeshBatchList = GetWorld().GetMeshBatchColloctor().GetMeshBatchList(); //Render Pipeline BeginFrameRendering(RenderContext, RenderCameras); foreach (Camera RenderCamera in RenderCameras) { RenderCamera.allowHDR = true; bool isSceneViewCam = RenderCamera.cameraType == CameraType.SceneView; #if UNITY_EDITOR if (isSceneViewCam) { ScriptableRenderContext.EmitWorldGeometryForSceneView(RenderCamera); } #endif //Prepare VisualEffects VFXManager.PrepareCamera(RenderCamera); //Prepare ViewUnifrom ViewUnifrom.UnpateBufferData(false, RenderCamera); //View RenderFamily CommandBuffer CmdBuffer = CommandBufferPool.Get(""); //Binding ViewParameter BeginCameraRendering(RenderContext, RenderCamera); CmdBuffer.DisableScissorRect(); ViewUnifrom.BindGPUProperty(CmdBuffer); RenderContext.SetupCameraProperties(RenderCamera); //Binding VisualEffects VFXManager.ProcessCameraCommand(RenderCamera, CmdBuffer); //Culling MeshBatch NativeArray <FPlane> ViewFrustum = new NativeArray <FPlane>(6, Allocator.Persistent); NativeArray <FVisibleMeshBatch> VisibleMeshBatchList = new NativeArray <FVisibleMeshBatch>(MeshBatchList.Length, Allocator.TempJob); Plane[] FrustumPlane = GeometryUtility.CalculateFrustumPlanes(RenderCamera); for (int PlaneIndex = 0; PlaneIndex < 6; PlaneIndex++) { ViewFrustum[PlaneIndex] = FrustumPlane[PlaneIndex]; } CullMeshBatch CullTask = new CullMeshBatch(); { CullTask.ViewFrustum = ViewFrustum; CullTask.ViewOrigin = RenderCamera.transform.position; CullTask.MeshBatchList = MeshBatchList; CullTask.VisibleMeshBatchList = VisibleMeshBatchList; } JobHandle CullTaskHandle = CullTask.Schedule(MeshBatchList.Length, 256); /*SortMeshBatch SortTask = new SortMeshBatch(); * { * SortTask.VisibleMeshBatchList = VisibleMeshBatchList; * } * JobHandle SortTaskHandle = SortTask.Schedule(CullTaskHandle);*/ //Culling Context ScriptableCullingParameters CullingParameter; RenderCamera.TryGetCullingParameters(out CullingParameter); CullingResults CullingResult = RenderContext.Cull(ref CullingParameter); CullTaskHandle.Complete(); //SortTaskHandle.Complete(); //Render Family RenderOpaqueDepth(RenderCamera, CullingResult); RenderOpaqueGBuffer(RenderCamera, CullingResult, VisibleMeshBatchList); RenderOpaqueMotion(RenderCamera, CullingResult); RenderSkyAtmosphere(RenderCamera); RenderPresentView(RenderCamera, GraphBuilder.ScopeTexture(InfinityShaderIDs.RT_ThinGBufferA), RenderCamera.targetTexture); //Draw DrawGizmos #if UNITY_EDITOR if (Handles.ShouldRenderGizmos()) { RenderGizmo(RenderCamera, GizmoSubset.PostImageEffects); } #endif //Execute RenderGraph GraphBuilder.Execute(RenderContext, GetWorld(), CmdBuffer, ViewUnifrom.FrameIndex); EndCameraRendering(RenderContext, RenderCamera); //Execute ViewRender RenderContext.ExecuteCommandBuffer(CmdBuffer); CommandBufferPool.Release(CmdBuffer); RenderContext.Submit(); //Prepare ViewUnifrom ViewUnifrom.UnpateBufferData(true, RenderCamera); //Release View ViewFrustum.Dispose(); VisibleMeshBatchList.Dispose(); } EndFrameRendering(RenderContext, RenderCameras); }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); if (Initialized) { return; } var presentParams = new PresentParameters { Windowed = true, SwapEffect = SwapEffect.Discard, AutoDepthStencilFormat = DepthFormat.D16, EnableAutoDepthStencil = true, PresentationInterval = PresentInterval.One }; var enumerator = Manager.Adapters.GetEnumerator(); while (enumerator.MoveNext()) { var adapterInfo = enumerator.Current as AdapterInformation; var d3dDeviceCaps = Manager.GetDeviceCaps(adapterInfo.Adapter, DeviceType.Hardware); var flags = d3dDeviceCaps.DeviceCaps.SupportsHardwareTransformAndLight ? CreateFlags.HardwareVertexProcessing : CreateFlags.SoftwareVertexProcessing; Device = new D3DDevice(adapterInfo.Adapter, d3dDeviceCaps.DeviceType, this, flags, presentParams); if (Device != null) { break; } } Device.DeviceReset += new EventHandler(OnResetDevice); OnResetDevice(Device, null); Instance = new RenderObject(Device, Cache, Definition, new TagTool.Common.RealPoint3d(), new TagTool.Common.RealEulerAngles3d()); if (Camera != null) { Camera.Dispose(); } var compression = Instance.RenderModel.Geometry.Compression.Count > 0 ? Instance.RenderModel.Geometry.Compression[0] : new TagTool.Geometry.RenderGeometryCompression { X = new TagTool.Common.Bounds <float>(float.MinValue, float.MaxValue), Y = new TagTool.Common.Bounds <float>(float.MinValue, float.MaxValue), Z = new TagTool.Common.Bounds <float>(float.MinValue, float.MaxValue), U = new TagTool.Common.Bounds <float>(float.MinValue, float.MaxValue), V = new TagTool.Common.Bounds <float>(float.MinValue, float.MaxValue) }; Camera = new RenderCamera(this) { Speed = 0.005f, Position = new Vector3(compression.X.Length + (Instance.Object.BoundingRadius * 2f), 0f, Instance.RenderModel.Nodes.FirstOrDefault().DefaultTranslation.Z), VerticalRadians = 6.161014f, HorizontalRadians = 3.14159f }; Camera.ComputePosition(); RenderTimer = new Timer { Interval = 10 }; RenderTimer.Tick += OnRender; Initialized = true; RenderTimer.Start(); }
// Start is called before the first frame update void Awake() { instance = this; CreateRT(); }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); if (Initialized) { return; } var presentParams = new PresentParameters { Windowed = true, SwapEffect = SwapEffect.Discard, AutoDepthStencilFormat = DepthFormat.D16, EnableAutoDepthStencil = true, PresentationInterval = PresentInterval.One }; var enumerator = Manager.Adapters.GetEnumerator(); while (enumerator.MoveNext()) { var adapterInfo = enumerator.Current as AdapterInformation; var d3dDeviceCaps = Manager.GetDeviceCaps(adapterInfo.Adapter, DeviceType.Hardware); var flags = d3dDeviceCaps.DeviceCaps.SupportsHardwareTransformAndLight ? CreateFlags.HardwareVertexProcessing : CreateFlags.SoftwareVertexProcessing; Device = new Direct3D.Device(adapterInfo.Adapter, d3dDeviceCaps.DeviceType, this, flags, presentParams); if (Device != null) { break; } } Device.DeviceReset += new EventHandler(OnResetDevice); OnResetDevice(Device, null); // TODO: load instances here... if (Camera != null) { Camera.Dispose(); } Camera = new RenderCamera(this) { Speed = 0.005f, Position = new Vector3(), VerticalRadians = 6.161014f, HorizontalRadians = 3.14159f }; Camera.ComputePosition(); RenderTimer = new Timer { Interval = 10 }; RenderTimer.Tick += OnRender; RenderTimer.Start(); Initialized = true; }
public void drawModel(GraphicsInterface gi, [In] ref RenderCamera camTrs) { drawModel(gi, Transform.Identity, ref camTrs); }
public bool drawModel(GraphicsInterface gi, byte drawLayers, ref RenderCamera camTrs) { return(drawModel(gi, Transform.Identity, drawLayers, ref camTrs)); }
public void drawModel(GraphicsInterface gi, Transform transform, [In] ref RenderCamera camTrs) { drawModel(gi, transform, 255, ref camTrs); }
public void draw(GraphicsInterface gi, ref Transform transform, byte drawLayers, ref RenderCamera camTrs, DrawOptions options = 0) { GeoNode NodeIter; GeoModel ModelIter; GeoMesh MeshIter; uint NodeIterPos; uint ModelIterPos; uint MeshIterPos; var new_transform = Local * transform; GL.PushMatrix(); Local.GL_Load(); if (this.forceBillboard) { camTrs.MakeBillboardAndRotateGL(ref transform); } if (0 != (SelfDrawLayerMask & drawLayers)) { for (ModelIter = FirstModel, ModelIterPos = ModelCount; 0 != ModelIterPos; ModelIter = ModelIter.Next, --ModelIterPos) { if (0 != (ModelIter.DrawLayerMask & drawLayers)) { for (MeshIter = ModelIter.First, MeshIterPos = ModelIter.Count; 0 != MeshIterPos; MeshIter = MeshIter.Next, --MeshIterPos) { if (0 != (MeshIter.DrawLayerMask & drawLayers)) { gi.Draw(ref MeshIter.State, Options: options); } } } } } for (NodeIter = FirstChild, NodeIterPos = NumImmediate; 0 != NodeIterPos; NodeIter = NodeIter.Sibling, --NodeIterPos) { if (0 != (NodeIter.DrawLayerMask & drawLayers)) { NodeIter.draw(gi, ref new_transform, drawLayers, ref camTrs, options); } } GL.PopMatrix(); }
//static bool old; public bool drawModel(GraphicsInterface gi, Transform transform, byte drawLayers, ref RenderCamera camTrs) { if (/*!old &&*/ null != (object)root) { return(root.draw(gi, transform, drawLayers, ref camTrs)); } bool started = false; for (int i = 0; i < meshes.Count; i++) { MeshData m = meshes[i]; if (0 == ((1 << (m.material.drawLayerBillboard & 7)) & drawLayers)) { continue; } //if (m.vertices == null || m.indices == null) return; if (!started) { started = true; GL.PushMatrix(); transform.GL_Load(); GL.EnableClientState(ArrayCap.VertexArray); GL.EnableClientState(ArrayCap.TextureCoordArray); GL.EnableClientState(ArrayCap.ColorArray); } if (m.texture != null) { GL.BindTexture(TextureTarget.Texture2D, m.texture.ID); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, m.texture.TextureParamS); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, m.texture.TextureParamT); } GL.BindBuffer(BufferTarget.ArrayBuffer, m.vbo); GL.VertexPointer(3, VertexPointerType.Float, 0, IntPtr.Zero); GL.BindBuffer(BufferTarget.ArrayBuffer, m.texBuf); GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, IntPtr.Zero); GL.BindBuffer(BufferTarget.ArrayBuffer, m.colorBuf); GL.ColorPointer(4, ColorPointerType.Float, 0, IntPtr.Zero); GL.BindBuffer(BufferTarget.ArrayBuffer, m.normalBuf); GL.NormalPointer(NormalPointerType.Float, 0, IntPtr.Zero); GL.BindBuffer(BufferTarget.ElementArrayBuffer, m.ibo); if (Globals.doWireframe) { GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line); } else { GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill); } GL.DrawElements(PrimitiveType.Triangles, m.indices.Length, DrawElementsType.UnsignedInt, IntPtr.Zero); if (Globals.doWireframe) { GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill); } } if (started) { GL.DisableClientState(ArrayCap.VertexArray); GL.DisableClientState(ArrayCap.TextureCoordArray); GL.DisableClientState(ArrayCap.ColorArray); GL.PopMatrix(); } return(started); }
/// <summary> /// Sets the renderer's new settings. /// </summary> /// <param name="NewSettings"></param> public void SetData(RenderSettings NewSettings) { this.Settings = NewSettings; this.Camera = new RenderCamera(NewSettings); }