public void DrawIds(MeshMaterialLibrary meshMat, List <Decal> decals, List <PointLight> pointLights, List <DirectionalLight> dirLights, EnvironmentSample envSample, List <DebugEntity> debug, Matrix viewProjection, Matrix view, EditorLogic.EditorSendData editorData) { _graphicsDevice.SetRenderTarget(_idRenderTarget2D); _graphicsDevice.BlendState = BlendState.Opaque; _graphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise; _graphicsDevice.DepthStencilState = DepthStencilState.Default; meshMat.Draw(MeshMaterialLibrary.RenderType.IdRender, viewProjection); //Now onto the billboards DrawBillboards(decals, pointLights, dirLights, envSample, debug, viewProjection, view); //Now onto the gizmos DrawGizmos(viewProjection, editorData, _assets); Rectangle sourceRectangle = new Rectangle(Mouse.GetState().X, Mouse.GetState().Y, 1, 1); Color[] retrievedColor = new Color[1]; try { if (sourceRectangle.X >= 0 && sourceRectangle.Y >= 0 && sourceRectangle.X < _idRenderTarget2D.Width - 2 && sourceRectangle.Y < _idRenderTarget2D.Height - 2) { _idRenderTarget2D.GetData(0, sourceRectangle, retrievedColor, 0, 1); } } catch { //nothing } HoveredId = IdGenerator.GetIdFromColor(retrievedColor[0]); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////// // FUNCTIONS //////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////// // MAIN FUNCTIONS //////////////////////////////////////////////////////////////////////////////////////////////////////////// //Done after Load public void Initialize(Assets assets, Space space, GraphicsDevice graphicsDevice) { _assets = assets; _physicsSpace = space; MeshMaterialLibrary = new MeshMaterialLibrary(graphicsDevice); SetUpEditorScene(graphicsDevice); }
public void DrawEditorElements(MeshMaterialLibrary meshMaterialLibrary, List <Decal> decals, List <PointLight> lights, List <DirectionalLight> dirLights, EnvironmentSample envSample, List <DebugEntity> debug, Matrix staticViewProjection, Matrix view, EditorLogic.EditorSendData editorData) { _graphicsDevice.SetRenderTarget(null); _graphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise; _graphicsDevice.DepthStencilState = DepthStencilState.Default; _graphicsDevice.BlendState = BlendState.Opaque; DrawGizmo(staticViewProjection, editorData); DrawBillboards(decals, lights, dirLights, envSample, debug, staticViewProjection, view, editorData); }
/// <summary> /// Create the projection matrices /// </summary> /// <param name="camera"></param> /// <param name="meshMaterialLibrary"></param> /// <param name="entities"></param> private void UpdateViewProjection(Camera camera, MeshMaterialLibrary meshMaterialLibrary, List <BasicEntity> entities) { _viewProjectionHasChanged = camera.HasChanged; //If the camera didn't do anything we don't need to update this stuff if (_viewProjectionHasChanged) { //We have processed the change, now setup for next frame as false camera.HasChanged = false; camera.HasMoved = false; //View matrix _view = Matrix.CreateLookAt(camera.Position, camera.Lookat, camera.Up); _inverseView = Matrix.Invert(_view); _projection = Matrix.CreatePerspectiveFieldOfView(camera.FieldOfView, GameSettings.g_ScreenWidth / (float)GameSettings.g_ScreenHeight, 1, GameSettings.g_FarPlane); Shaders.GBufferEffectParameter_Camera.SetValue(camera.Position); _viewProjection = _view * _projection; //this is the unjittered viewProjection. For some effects we don't want the jittered one _staticViewProjection = _viewProjection; //Transformation for TAA - from current view back to the old view projection _currentViewToPreviousViewProjection = Matrix.Invert(_view) * _previousViewProjection; _previousViewProjection = _viewProjection; _inverseViewProjection = Matrix.Invert(_viewProjection); if (_boundingFrustum == null) { _boundingFrustum = new BoundingFrustum(_staticViewProjection); } else { _boundingFrustum.Matrix = _staticViewProjection; } Matrix id = Matrix.Identity; } //We need to update whether or not entities are in our boundingFrustum and then cull them or not! meshMaterialLibrary.FrustumCulling(entities, _boundingFrustum, _viewProjectionHasChanged, camera.Position); //Performance Profiler if (GameSettings.d_profiler) { long performanceCurrentTime = _performanceTimer.ElapsedTicks; GameStats.d_profileUpdateViewProjection = performanceCurrentTime - _performancePreviousTime; _performancePreviousTime = performanceCurrentTime; } }
public void DrawOutlines(MeshMaterialLibrary meshMat, Matrix viewProjection, bool drawAll, int hoveredId, EditorLogic.EditorSendData editorData, bool mouseMoved) { _graphicsDevice.SetRenderTarget(_idRenderTarget2D); if (!mouseMoved) { _graphicsDevice.Clear(ClearOptions.Target, Color.Black, 0, 0); } else { _graphicsDevice.Clear(Color.Black); } _graphicsDevice.BlendState = BlendState.Opaque; _graphicsDevice.DepthStencilState = DepthStencilState.Default; _graphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise; int selectedId = editorData.SelectedObjectId; //Selected entity if (selectedId != 0) { //UPdate the size of our outlines! if (!drawAll) { meshMat.Draw(MeshMaterialLibrary.RenderType.IdOutline, viewProjection, false, false, false, selectedId); } Shaders.IdRenderEffectParameterColorId.SetValue(_selectedColor); meshMat.Draw(MeshMaterialLibrary.RenderType.IdOutline, viewProjection, false, false, outlined: true, outlineId: selectedId); } if (selectedId != hoveredId && hoveredId != 0 && mouseMoved) { if (!drawAll) { meshMat.Draw(MeshMaterialLibrary.RenderType.IdOutline, viewProjection, false, false, false, hoveredId); } Shaders.IdRenderEffectParameterColorId.SetValue(_hoveredColor); meshMat.Draw(MeshMaterialLibrary.RenderType.IdOutline, viewProjection, false, false, outlined: true, outlineId: hoveredId); } }
public void Draw(MeshMaterialLibrary meshMat, List <Decal> decals, List <PointLight> pointLights, List <DirectionalLight> dirLights, EnvironmentSample envSample, List <DebugEntity> debug, Matrix viewProjection, Matrix view, EditorLogic.EditorSendData editorData, bool mouseMoved) { if (editorData.GizmoTransformationMode) { _graphicsDevice.SetRenderTarget(_idRenderTarget2D); _graphicsDevice.Clear(Color.Black); return; } if (mouseMoved) { DrawIds(meshMat, decals, pointLights, dirLights, envSample, debug, viewProjection, view, editorData); } if (GameSettings.e_drawoutlines) { DrawOutlines(meshMat, viewProjection, mouseMoved, HoveredId, editorData, mouseMoved); } }
/// <summary> /// Draw all our meshes to the GBuffer - albedo, normal, depth - for further computation /// </summary> /// <param name="meshMaterialLibrary"></param> private void DrawTextureBuffer(MeshMaterialLibrary meshMaterialLibrary) { if (!Input.WasKeyPressed(Keys.C) && !GameSettings.g_UpdateShading) { return; } _graphicsDevice.SetRenderTarget(_textureBuffer); _graphicsDevice.Clear(Color.TransparentBlack); _graphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise; _graphicsDevice.DepthStencilState = DepthStencilState.None; meshMaterialLibrary.Draw(renderType: MeshMaterialLibrary.RenderType.TextureBuffer, graphicsDevice: _graphicsDevice, viewProjection: _viewProjection, lightViewPointChanged: true, view: _view); //Performance Profiler if (GameSettings.d_profiler) { long performanceCurrentTime = _performanceTimer.ElapsedTicks; GameStats.d_profileDrawGBuffer = performanceCurrentTime - _performancePreviousTime; _performancePreviousTime = performanceCurrentTime; } }
private void DrawObjects(MeshMaterialLibrary meshMaterialLibrary) { _graphicsDevice.SetRenderTarget(null); _graphicsDevice.Clear(GameSettings.g_UpdateShading ? Color.CadetBlue : Color.DarkViolet); _graphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise; _graphicsDevice.DepthStencilState = DepthStencilState.Default; Shaders.GBufferEffectParameter_Material_Texture.SetValue(GameSettings.g_FixSeams ? _textureBufferSeamFix : _textureBuffer); meshMaterialLibrary.Draw(renderType: MeshMaterialLibrary.RenderType.FinalMesh, graphicsDevice: _graphicsDevice, viewProjection: _viewProjection, lightViewPointChanged: true, view: _view); _graphicsDevice.RasterizerState = RasterizerState.CullClockwise; _graphicsDevice.BlendState = BlendState.NonPremultiplied; //Skybox ModelMeshPart part = _assets.Isosphere.Meshes[0].MeshParts[0]; _graphicsDevice.SetVertexBuffer(part.VertexBuffer); _graphicsDevice.Indices = (part.IndexBuffer); int primitiveCount = part.PrimitiveCount; int vertexOffset = part.VertexOffset; //int vCount = meshLib.GetMesh().NumVertices; int startIndex = part.StartIndex; Matrix world = Matrix.CreateScale(100); Shaders.GBufferEffectParameter_WorldViewProj.SetValue(world * _viewProjection); Shaders.GBufferEffectParameter_WorldIT.SetValue(world); Shaders.GBufferEffectTechniques_DrawSkybox.Passes[0].Apply(); _graphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, vertexOffset, startIndex, primitiveCount); //Performance Profiler if (GameSettings.d_profiler) { long performanceCurrentTime = _performanceTimer.ElapsedTicks; GameStats.d_profileDrawGBuffer = performanceCurrentTime - _performancePreviousTime; _performancePreviousTime = performanceCurrentTime; } }
//////////////////////////////////////////////////////////////////////////////////////////////////////// // RENDER FUNCTIONS //////////////////////////////////////////////////////////////////////////////////////////////////////// #region MAIN DRAW FUNCTIONS //////////////////////////////////////////////////////////////////////////////////////////////////// // MAIN DRAW FUNCTIONS //////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Main Draw function of the game /// </summary> /// <param name="camera">view point of the renderer</param> /// <param name="meshMaterialLibrary">a class that has stored all our mesh data</param> /// <param name="entities">entities and their properties</param> /// <param name="pointLights"></param> /// <param name="directionalLights"></param> /// <param name="editorData">The data passed from our editor logic</param> /// <param name="gameTime"></param> /// <returns></returns> public void Draw(Camera camera, MeshMaterialLibrary meshMaterialLibrary, List <BasicEntity> entities, List <PointLightSource> pointLights, List <DirectionalLightSource> directionalLights, EditorLogic.EditorSendData editorData, GameTime gameTime) { //Reset the stat counter, so we can count stats/information for this frame only ResetStats(); //Update the mesh data for changes in physics etc. meshMaterialLibrary.FrustumCullingStartFrame(entities); //Check if we changed some drastic stuff for which we need to reload some elements CheckRenderChanges(directionalLights); //Render ShadowMaps //DrawShadowMaps(meshMaterialLibrary, entities, pointLights, directionalLights, camera); //Update our view projection matrices if the camera moved UpdateViewProjection(camera, meshMaterialLibrary, entities); GS.BeginMark("DrawTextureBuffer", Color.Red); //Draw our meshes to the G Buffer DrawTextureBuffer(meshMaterialLibrary); GS.EndMark("DrawTextureBuffer"); FixSeams(); GS.BeginMark("DrawMeshes", Color.Blue); DrawObjects(meshMaterialLibrary); GS.EndMark("DrawMeshes"); //Draw the final rendered image, change the output based on user input to show individual buffers/rendertargets RenderMode(); //Draw (debug) lines LineHelperManager.Draw(_graphicsDevice, _staticViewProjection); //Set up the frustum culling for the next frame meshMaterialLibrary.FrustumCullingFinalizeFrame(entities); }
/// <summary> /// Main Logic for the editor part /// </summary> /// <param name="gameTime"></param> /// <param name="entities"></param> /// <param name="data"></param> public void Update(GameTime gameTime, List <BasicEntity> entities, List <Decal> decals, List <PointLight> pointLights, List <DirectionalLight> dirLights, EnvironmentSample envSample, List <DebugEntity> debugEntities, EditorReceivedData data, MeshMaterialLibrary meshMaterialLibrary) { if (!GameSettings.e_enableeditor) { return; } if (!DebugScreen.ConsoleOpen) { if (Input.WasKeyPressed(Keys.R)) { GameStats.e_gizmoMode = GizmoModes.Rotation; } if (Input.WasKeyPressed(Keys.T)) { GameStats.e_gizmoMode = GizmoModes.Translation; } if (Input.WasKeyPressed(Keys.Z)) { GameStats.e_gizmoMode = GizmoModes.Scale; } } _gizmoMode = GameStats.e_gizmoMode; int hoveredId = data.HoveredId; if (_gizmoTransformationMode) { if (Input.mouseState.LeftButton == ButtonState.Pressed) { GizmoControl(_gizmoId, data); } else { _gizmoTransformationMode = false; } } else if (Input.WasLMBClicked() && !GUIControl.UIWasUsed) { previousMouseX = Input.mouseState.X; previousMouseY = Input.mouseState.Y; //Gizmos if (hoveredId >= 1 && hoveredId <= 3) { _gizmoId = hoveredId; GizmoControl(_gizmoId, data); return; } if (hoveredId <= 0) { SelectedObject = null; return; } bool foundnew = false; //Get the selected entity! for (int index = 0; index < entities.Count; index++) { var VARIABLE = entities[index]; if (VARIABLE.Id == hoveredId) { SelectedObject = VARIABLE; foundnew = true; break; } } if (foundnew == false) { for (int index = 0; index < decals.Count; index++) { Decal decal = decals[index]; if (decal.Id == hoveredId) { SelectedObject = decal; break; } } for (int index = 0; index < pointLights.Count; index++) { PointLight pointLight = pointLights[index]; if (pointLight.Id == hoveredId) { SelectedObject = pointLight; break; } } for (int index = 0; index < dirLights.Count; index++) { DirectionalLight directionalLight = dirLights[index]; if (directionalLight.Id == hoveredId) { SelectedObject = directionalLight; break; } } { if (envSample.Id == hoveredId) { SelectedObject = envSample; } } for (int index = 0; index < debugEntities.Count; index++) { DirectionalLight debugEntity = dirLights[index]; if (debugEntity.Id == hoveredId) { SelectedObject = debugEntity; break; } } } } //Controls if (Input.WasKeyPressed(Keys.Delete)) { //Find object if (SelectedObject is BasicEntity) { entities.Remove((BasicEntity)SelectedObject); meshMaterialLibrary.DeleteFromRegistry((BasicEntity)SelectedObject); SelectedObject = null; } else if (SelectedObject is Decal) { decals.Remove((Decal)SelectedObject); SelectedObject = null; } else if (SelectedObject is PointLight) { pointLights.Remove((PointLight)SelectedObject); SelectedObject = null; } else if (SelectedObject is DirectionalLight) { dirLights.Remove((DirectionalLight)SelectedObject); SelectedObject = null; } } if (Input.WasKeyPressed(Keys.Insert) || (Input.keyboardState.IsKeyDown(Keys.LeftControl) && Input.WasKeyPressed(Keys.C))) { if (SelectedObject is BasicEntity) { BasicEntity copy = (BasicEntity)SelectedObject.Clone; copy.RegisterInLibrary(meshMaterialLibrary); entities.Add(copy); } else if (SelectedObject is Decal) { Decal copy = (Decal)SelectedObject.Clone; decals.Add(copy); } else if (SelectedObject is PointLight) { PointLight copy = (PointLight)SelectedObject.Clone; pointLights.Add(copy); } else if (SelectedObject is DirectionalLight) { DirectionalLight copy = (DirectionalLight)SelectedObject.Clone; dirLights.Add(copy); } } }
public void Dispose(MeshMaterialLibrary library) { library.DeleteFromRegistry(this); }
public void RegisterInLibrary(MeshMaterialLibrary library) { library.Register(Material, Model, WorldTransform); }
public BasicEntity(Model model, MaterialEffect material, Vector3 position, double angleZ, double angleX, double angleY, Vector3 scale, MeshMaterialLibrary library = null, Entity physicsObject = null) { Id = IdGenerator.GetNewId(); WorldTransform = new TransformMatrix(Matrix.Identity, Id); Position = position; AngleZ = angleZ; AngleX = angleX; AngleY = angleY; Scale = scale; RotationMatrix = Matrix.CreateRotationX((float)AngleX) * Matrix.CreateRotationY((float)AngleY) * Matrix.CreateRotationZ((float)AngleZ); Material = material; Model = model; if (library != null) { RegisterInLibrary(library); } if (physicsObject != null) { RegisterPhysics(physicsObject); } }
/// <summary> /// Only one shadow map needed for a directional light /// </summary> /// <param name="light"></param> /// <param name="shadowResolution"></param> /// <param name="meshMaterialLibrary"></param> /// <param name="entities"></param> private void CreateShadowMapDirectionalLight(GraphicsDevice graphicsDevice, DirectionalLight light, int shadowResolution, MeshMaterialLibrary meshMaterialLibrary, List <BasicEntity> entities) { //Create a renderTarget if we don't have one yet if (light.ShadowMap == null) { //if (lightSource.ShadowFiltering != DirectionalLightSource.ShadowFilteringTypes.VSM) //{ light.ShadowMap = new RenderTarget2D(graphicsDevice, shadowResolution, shadowResolution, false, SurfaceFormat.Single, DepthFormat.Depth24, 0, RenderTargetUsage.DiscardContents); //} //else //For a VSM shadowMap we need 2 components //{ // lightSource.ShadowMap = new RenderTarget2D(_graphicsDevice, shadowResolution, shadowResolution, false, // SurfaceFormat.Vector2, DepthFormat.Depth24, 0, RenderTargetUsage.DiscardContents); //} } if (light.HasChanged) { Matrix lightProjection = Matrix.CreateOrthographic(light.ShadowSize, light.ShadowSize, -light.ShadowDepth, light.ShadowDepth); Matrix lightView = Matrix.CreateLookAt(light.Position, light.Position + light.Direction, Vector3.Down); light.LightView = lightView; light.LightViewProjection = lightView * lightProjection; _boundingFrustumShadow = new BoundingFrustum(light.LightViewProjection); graphicsDevice.SetRenderTarget(light.ShadowMap); graphicsDevice.Clear(ClearOptions.DepthBuffer, Color.White, 1, 0); meshMaterialLibrary.FrustumCulling(entities, _boundingFrustumShadow, true, light.Position); // Rendering! _FarClip.SetValue(light.ShadowDepth); _SizeBias.SetValue(GameSettings.ShadowBias * 2048 / light.ShadowResolution); meshMaterialLibrary.Draw(MeshMaterialLibrary.RenderType.ShadowLinear, light.LightViewProjection, light.HasChanged, false, false, 0, light.LightView, renderModule: this); } else { _boundingFrustumShadow = new BoundingFrustum(light.LightViewProjection); bool hasAnyObjectMoved = meshMaterialLibrary.FrustumCulling(entities: entities, boundingFrustrum: _boundingFrustumShadow, hasCameraChanged: false, cameraPosition: light.Position); if (!hasAnyObjectMoved) { return; } meshMaterialLibrary.FrustumCulling(entities: entities, boundingFrustrum: _boundingFrustumShadow, hasCameraChanged: true, cameraPosition: light.Position); graphicsDevice.SetRenderTarget(light.ShadowMap); graphicsDevice.Clear(ClearOptions.DepthBuffer, Color.White, 1, 0); _FarClip.SetValue(light.ShadowDepth); _SizeBias.SetValue(GameSettings.ShadowBias * 2048 / light.ShadowResolution); meshMaterialLibrary.Draw(MeshMaterialLibrary.RenderType.ShadowLinear, light.LightViewProjection, false, true, false, 0, light.LightView, renderModule: this); } //Blur! //if (lightSource.ShadowFiltering == DirectionalLightSource.ShadowFilteringTypes.VSM) //{ // lightSource.ShadowMap = _gaussianBlur.DrawGaussianBlur(lightSource.ShadowMap); //} }
public void Draw(GraphicsDevice graphicsDevice, MeshMaterialLibrary meshMaterialLibrary, List <BasicEntity> entities, List <PointLight> pointLights, List <DirectionalLight> dirLights, Camera camera) { _pass = Passes.Omnidirectional; //Go through all our point lights for (int index = 0; index < pointLights.Count; index++) { PointLight light = pointLights[index]; if (!light.IsEnabled) { continue; } //If we don't see the light we shouldn't update. This is actually wrong, can lead to mistakes, //if we implement it like this we should rerender once we enter visible space again. //if (_boundingFrustum.Contains(light.BoundingSphere) == ContainmentType.Disjoint) //{ // continue; //} if (light.CastShadows) { //A poing light has 6 shadow maps, add that to our stat counter. These are total shadow maps, not updated ones GameStats.shadowMaps += 6; //Update if we didn't initialize yet or if we are dynamic if (!light.StaticShadows || light.ShadowMap == null) { CreateShadowCubeMap(graphicsDevice, light, light.ShadowResolution, meshMaterialLibrary, entities); light.HasChanged = false; camera.HasChanged = true; } } } _pass = Passes.Directional; int dirLightShadowedWithSSBlur = 0; for (int index = 0; index < dirLights.Count; index++) { DirectionalLight light = dirLights[index]; if (!light.IsEnabled) { continue; } if (light.CastShadows) { GameStats.shadowMaps += 1; CreateShadowMapDirectionalLight(graphicsDevice, light, light.ShadowResolution, meshMaterialLibrary, entities); camera.HasChanged = true; light.HasChanged = false; if (light.ScreenSpaceShadowBlur) { dirLightShadowedWithSSBlur++; } } if (dirLightShadowedWithSSBlur > 1) { throw new NotImplementedException( "Only one shadowed DirectionalLight with screen space blur is supported right now"); } } }
/// <summary> /// Draw forward shaded, alpha blended materials. Very basic and unoptimized algorithm. Can be improved to use tiling in future. /// </summary> /// <param name="graphicsDevice"></param> /// <param name="output"></param> /// <param name="meshMat"></param> /// <param name="viewProjection"></param> /// <param name="camera"></param> /// <param name="pointLights"></param> /// <param name="frustum"></param> /// <returns></returns> public RenderTarget2D Draw(GraphicsDevice graphicsDevice, RenderTarget2D output, MeshMaterialLibrary meshMat, Matrix viewProjection, Camera camera, List <PointLight> pointLights, BoundingFrustum frustum) { graphicsDevice.DepthStencilState = DepthStencilState.Default; SetupLighting(camera, pointLights, frustum); //Draw Frustum debug test //Matrix view = Matrix.CreateLookAt(new Vector3(-88, -11f, 4), new Vector3(38, 8, 32), Vector3.UnitZ); //Matrix projection = Matrix.CreatePerspectiveFieldOfView((float)(Math.PI / 2), 1.6f, 1, 100); //BoundingFrustumEx frustum2 = new BoundingFrustumEx(view * projection); //LineHelperManager.AddFrustum(frustum2, 1, Color.Red); //Vector3[] corners = frustum.GetCorners(); //BoundingFrustumEx frustum3 = new BoundingFrustumEx(ref corners); //TiledLighting(frustum, pointLights, 20, 10); meshMat.Draw(MeshMaterialLibrary.RenderType.Forward, viewProjection, renderModule: this); return(output); }
public BasicEntity(ModelDefinition modelbb, MaterialEffect material, Vector3 position, double angleZ, double angleX, double angleY, Vector3 scale, MeshMaterialLibrary library = null, Entity physicsObject = null) { Id = IdGenerator.GetNewId(); Name = GetType().Name + " " + Id; WorldTransform = new TransformMatrix(Matrix.Identity, Id); ModelDefinition = modelbb; Model = modelbb.Model; BoundingBox = modelbb.BoundingBox; BoundingBoxOffset = modelbb.BoundingBoxOffset; SignedDistanceField = modelbb.SDF; Material = material; Position = position; Scale = scale; RotationMatrix = Matrix.CreateRotationX((float)angleX) * Matrix.CreateRotationY((float)angleY) * Matrix.CreateRotationZ((float)angleZ); if (library != null) { RegisterInLibrary(library); } if (physicsObject != null) { RegisterPhysics(physicsObject); } WorldTransform.World = Matrix.CreateScale(Scale) * RotationMatrix * Matrix.CreateTranslation(Position); WorldTransform.Scale = Scale; WorldTransform.InverseWorld = Matrix.Invert(Matrix.CreateTranslation(BoundingBoxOffset * Scale) * RotationMatrix * Matrix.CreateTranslation(Position)); }
/// <summary> /// Main Logic for the editor part /// </summary> /// <param name="gameTime"></param> /// <param name="entities"></param> /// <param name="data"></param> public void Update(GameTime gameTime, List <BasicEntity> entities, List <PointLightSource> pointLights, List <DirectionalLightSource> dirLights, EditorReceivedData data, MeshMaterialLibrary meshMaterialLibrary) { if (Input.WasKeyPressed(Keys.R)) { _gizmoMode = GizmoModes.Rotation; } if (Input.WasKeyPressed(Keys.T)) { _gizmoMode = GizmoModes.Translation; } int hoveredId = data.HoveredId; if (_gizmoTransformationMode) { if (Input.mouseState.LeftButton == ButtonState.Pressed) { GizmoControl(_gizmoId, data); } else { _gizmoTransformationMode = false; } } else if (Input.WasLMBPressed()) { //Gizmos if (hoveredId >= 1 && hoveredId <= 3) { _gizmoId = hoveredId; GizmoControl(_gizmoId, data); return; } if (hoveredId <= 0) { SelectedObject = null; return; } bool foundnew = false; //Get the selected entity! for (int index = 0; index < entities.Count; index++) { var VARIABLE = entities[index]; if (VARIABLE.Id == hoveredId) { SelectedObject = VARIABLE; foundnew = true; break; } } if (foundnew == false) { for (int index = 0; index < pointLights.Count; index++) { PointLightSource pointLightSource = pointLights[index]; if (pointLightSource.Id == hoveredId) { SelectedObject = pointLightSource; break; } } for (int index = 0; index < dirLights.Count; index++) { DirectionalLightSource directionalLightSource = dirLights[index]; if (directionalLightSource.Id == hoveredId) { SelectedObject = directionalLightSource; break; } } } } //Controls if (Input.WasKeyPressed(Keys.Delete)) { //Find object if (SelectedObject is BasicEntity) { entities.Remove((BasicEntity)SelectedObject); meshMaterialLibrary.DeleteFromRegistry((BasicEntity)SelectedObject); SelectedObject = null; } else if (SelectedObject is PointLightSource) { pointLights.Remove((PointLightSource)SelectedObject); SelectedObject = null; } else if (SelectedObject is DirectionalLightSource) { dirLights.Remove((DirectionalLightSource)SelectedObject); SelectedObject = null; } } if (Input.WasKeyPressed(Keys.Insert)) { if (SelectedObject is BasicEntity) { BasicEntity copy = (BasicEntity)SelectedObject.Clone; copy.RegisterInLibrary(meshMaterialLibrary); entities.Add(copy); } else if (SelectedObject is PointLightSource) { PointLightSource copy = (PointLightSource)SelectedObject.Clone; pointLights.Add(copy); } else if (SelectedObject is DirectionalLightSource) { DirectionalLightSource copy = (DirectionalLightSource)SelectedObject.Clone; dirLights.Add(copy); } } if (SelectedObject != null) { DebugScreen.AddString(SelectedObject.Position.ToString()); } }
public void Draw(GraphicsDevice _graphicsDevice, RenderTargetBinding[] _renderTargetBinding, MeshMaterialLibrary meshMaterialLibrary, Matrix _viewProjection, Matrix _view) { _graphicsDevice.SetRenderTargets(_renderTargetBinding); //Clear the GBuffer if (GameSettings.g_ClearGBuffer) { _graphicsDevice.RasterizerState = RasterizerState.CullNone; _graphicsDevice.BlendState = BlendState.Opaque; _graphicsDevice.DepthStencilState = DepthStencilState.Default; _clearGBufferPass.Apply(); _fullScreenTriangle.Draw(_graphicsDevice); } //Draw the Gbuffer! meshMaterialLibrary.Draw(renderType: MeshMaterialLibrary.RenderType.Opaque, viewProjection: _viewProjection, lightViewPointChanged: true, view: _view, renderModule: this); }
public void DrawIds(MeshMaterialLibrary meshMaterialLibrary, List <Decal> decals, List <PointLight> lights, List <DirectionalLight> dirLights, EnvironmentSample envSample, List <DebugEntity> debug, Matrix staticViewProjection, Matrix view, EditorLogic.EditorSendData editorData) { _idAndOutlineRenderer.Draw(meshMaterialLibrary, decals, lights, dirLights, envSample, debug, staticViewProjection, view, editorData, _mouseMovement); }
public RenderTarget2D Draw(GraphicsDevice graphicsDevice, RenderTarget2D input, RenderTarget2D output, MeshMaterialLibrary meshMat, Matrix viewProjection) { graphicsDevice.SetRenderTarget(output); graphicsDevice.DepthStencilState = DepthStencilState.Default; meshMat.Draw(MeshMaterialLibrary.RenderType.SubsurfaceScattering, viewProjection, renderModule: this); return(output); }
/// <summary> /// Create the shadow map for each cubemapside, then combine into one cubemap /// </summary> /// <param name="light"></param> /// <param name="size"></param> /// <param name="meshMaterialLibrary"></param> /// <param name="entities"></param> private void CreateShadowCubeMap(GraphicsDevice graphicsDevice, PointLight light, int size, MeshMaterialLibrary meshMaterialLibrary, List <BasicEntity> entities) { //For VSM we need 2 channels, -> Vector2 //todo: check if we need preserve contents if (light.ShadowMap == null) { light.ShadowMap = new RenderTarget2D(graphicsDevice, size, size * 6, false, SurfaceFormat.HalfSingle, DepthFormat.Depth24, 0, RenderTargetUsage.PreserveContents); } Matrix lightViewProjection = new Matrix(); CubeMapFace cubeMapFace; // = CubeMapFace.NegativeX; if (light.HasChanged) { graphicsDevice.SetRenderTarget(light.ShadowMap); Matrix lightProjection = Matrix.CreatePerspectiveFieldOfView((float)(Math.PI / 2), 1, 1, light.Radius); Matrix lightView; // = identity //Reset the blur array light.faceBlurCount = new int[6]; graphicsDevice.SetRenderTarget(light.ShadowMap); graphicsDevice.Clear(Color.Black); for (int i = 0; i < 6; i++) { // render the scene to all cubemap faces cubeMapFace = (CubeMapFace)i; switch (cubeMapFace) { case CubeMapFace.PositiveX: { lightView = Matrix.CreateLookAt(light.Position, light.Position + Vector3.UnitX, Vector3.UnitZ); lightViewProjection = lightView * lightProjection; light.LightViewProjectionPositiveX = lightViewProjection; break; } case CubeMapFace.NegativeX: { lightView = Matrix.CreateLookAt(light.Position, light.Position - Vector3.UnitX, Vector3.UnitZ); lightViewProjection = lightView * lightProjection; light.LightViewProjectionNegativeX = lightViewProjection; break; } case CubeMapFace.PositiveY: { lightView = Matrix.CreateLookAt(light.Position, light.Position + Vector3.UnitY, Vector3.UnitZ); lightViewProjection = lightView * lightProjection; light.LightViewProjectionPositiveY = lightViewProjection; break; } case CubeMapFace.NegativeY: { lightView = Matrix.CreateLookAt(light.Position, light.Position - Vector3.UnitY, Vector3.UnitZ); lightViewProjection = lightView * lightProjection; light.LightViewProjectionNegativeY = lightViewProjection; break; } case CubeMapFace.PositiveZ: { lightView = Matrix.CreateLookAt(light.Position, light.Position + Vector3.UnitZ, Vector3.UnitX); lightViewProjection = lightView * lightProjection; light.LightViewProjectionPositiveZ = lightViewProjection; break; } case CubeMapFace.NegativeZ: { lightView = Matrix.CreateLookAt(light.Position, light.Position - Vector3.UnitZ, Vector3.UnitX); lightViewProjection = lightView * lightProjection; light.LightViewProjectionNegativeZ = lightViewProjection; break; } } if (_boundingFrustumShadow != null) { _boundingFrustumShadow.Matrix = lightViewProjection; } else { _boundingFrustumShadow = new BoundingFrustum(lightViewProjection); } meshMaterialLibrary.FrustumCulling(entities, _boundingFrustumShadow, true, light.Position); // Rendering! graphicsDevice.Viewport = new Viewport(0, light.ShadowResolution * (int)cubeMapFace, light.ShadowResolution, light.ShadowResolution); //_graphicsDevice.ScissorRectangle = new Rectangle(0, light.ShadowResolution* (int) cubeMapFace, light.ShadowResolution, light.ShadowResolution); _FarClip.SetValue(light.Radius); _LightPositionWS.SetValue(light.Position); graphicsDevice.ScissorRectangle = new Rectangle(0, light.ShadowResolution * (int)cubeMapFace, light.ShadowResolution, light.ShadowResolution); meshMaterialLibrary.Draw(renderType: MeshMaterialLibrary.RenderType.ShadowOmnidirectional, viewProjection: lightViewProjection, lightViewPointChanged: true, hasAnyObjectMoved: light.HasChanged, renderModule: this); } } else { bool draw = false; for (int i = 0; i < 6; i++) { // render the scene to all cubemap faces cubeMapFace = (CubeMapFace)i; switch (cubeMapFace) { case CubeMapFace.NegativeX: lightViewProjection = light.LightViewProjectionNegativeX; break; case CubeMapFace.NegativeY: lightViewProjection = light.LightViewProjectionNegativeY; break; case CubeMapFace.NegativeZ: lightViewProjection = light.LightViewProjectionNegativeZ; break; case CubeMapFace.PositiveX: lightViewProjection = light.LightViewProjectionPositiveX; break; case CubeMapFace.PositiveY: lightViewProjection = light.LightViewProjectionPositiveY; break; case CubeMapFace.PositiveZ: lightViewProjection = light.LightViewProjectionPositiveZ; break; } if (_boundingFrustumShadow != null) { _boundingFrustumShadow.Matrix = lightViewProjection; } else { _boundingFrustumShadow = new BoundingFrustum(lightViewProjection); } bool hasAnyObjectMoved = meshMaterialLibrary.FrustumCulling(entities, _boundingFrustumShadow, false, light.Position); if (!hasAnyObjectMoved) { continue; } if (!draw) { graphicsDevice.SetRenderTarget(light.ShadowMap); draw = true; } graphicsDevice.Viewport = new Viewport(0, light.ShadowResolution * (int)cubeMapFace, light.ShadowResolution, light.ShadowResolution); //_graphicsDevice.Clear(Color.TransparentBlack); //_graphicsDevice.Clear(ClearOptions.DepthBuffer, Color.White, 0, 0); graphicsDevice.ScissorRectangle = new Rectangle(0, light.ShadowResolution * (int)cubeMapFace, light.ShadowResolution, light.ShadowResolution); meshMaterialLibrary.Draw(renderType: MeshMaterialLibrary.RenderType.ShadowOmnidirectional, viewProjection: lightViewProjection, lightViewPointChanged: light.HasChanged, hasAnyObjectMoved: true, renderModule: this); } } }