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);
}
