public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
this.factory = factory;
effect = factory.GetEffect("DownScaling", false, true);
luminance = factory.GetEffect("Luminance", false, true);
threshold = factory.GetEffect("Threshold", false, true);
fULLGPUBlur = factory.GetEffect("FULLGPUBlur", false, true);
tone = factory.GetEffect("ToneHdr", false, true);
int chainLength = 1;
int startSize = (int)MathHelper.Min(ginfo.BackBufferWidth / 16, ginfo.BackBufferHeight / 16);
int size = 16;
for (size = 16; size < startSize; size *= 4)
{
chainLength++;
}
luminanceChain = new RenderTarget2D[chainLength];
size /= 4;
for (int i = 0; i < chainLength; i++)
{
luminanceChain[i] = factory.CreateRenderTarget(size, size, SurfaceFormat.Single, false, DepthFormat.None);
size /= 4;
}
currentFrameLuminance = factory.CreateRenderTarget(1, 1, SurfaceFormat.Single, false, DepthFormat.None, 0, RenderTargetUsage.PreserveContents);
currentFrameAdaptedLuminance = factory.CreateRenderTarget(1, 1, SurfaceFormat.Single, false, DepthFormat.None, 0, RenderTargetUsage.PreserveContents);
lastFrameAdaptedLuminance = factory.CreateRenderTarget(1, 1, SurfaceFormat.Single, false, DepthFormat.None, 0, RenderTargetUsage.PreserveContents);
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
//Load the asset
effect = factory.GetEffect("opacity", false, true);
tex = factory.GetTexture2D(textureName);
this.factory = factory;
}
/// <summary>
/// Load graphics content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(Engine.GraphicInfo GraphicInfo, Engine.GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
videoPlayer = new VideoPlayer();
myVideoFile = contentManager.GetAsset <Video>(location);
videoPlayer.IsLooped = false;
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
effect = factory.GetEffect("Scatter", false, true);
to = new ToBlackPostEffect();
to.Init(ginfo, factory);
tr2d = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
this.toon = factory.GetEffect("toon1", false, true);
this.line = factory.GetEffect("LineDetection", false, true);
this.cell = factory.GetTexture2D("Toon", true);
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
}
//EffectParameter PcolorMap;
//EffectParameter PlightMap;
#endregion
#region IDeferredFinalCombination Members
public void LoadContent(IContentManager manager, Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, bool useFloatBuffer, bool saveToTexture)
{
this.useFloatBuffer = useFloatBuffer;
this.ginfo = ginfo;
this.saveToTexture = saveToTexture;
finalCombineEffect = manager.GetAsset <Effect>("CombineFinal", true);
PhalfPixel = finalCombineEffect.Parameters["halfPixel"];
PambientColor = finalCombineEffect.Parameters["ambientColor"];
//PEXTRA1 = finalCombineEffect.Parameters["EXTRA1"];
//PcolorMap = finalCombineEffect.Parameters["colorMap"];
//PlightMap = finalCombineEffect.Parameters["lightMap"];
PhalfPixel.SetValue(ginfo.HalfPixel);
if (saveToTexture)
{
if (useFloatBuffer)
{
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.HdrBlendable, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample, RenderTargetUsage.DiscardContents);
}
else
{
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample, RenderTargetUsage.DiscardContents);
}
}
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
//Load the asset
effect = factory.GetEffect("gamma", true, true);
switch (_gType)
{
case GammaType.Normal:
effect.CurrentTechnique = effect.Techniques[0];
break;
case GammaType.Simple:
effect.CurrentTechnique = effect.Techniques[1];
break;
case GammaType.InvertNormal:
effect.CurrentTechnique = effect.Techniques[2];
break;
case GammaType.InvertSimple:
effect.CurrentTechnique = effect.Techniques[3];
break;
case GammaType.VerySimple:
effect.CurrentTechnique = effect.Techniques[4];
break;
case GammaType.InvertVerySimple:
effect.CurrentTechnique = effect.Techniques[5];
break;
default:
break;
}
}
protected override void Initialize(Engine.EngineStuff engine, Engine.GraphicFactory factory, Engine.GraphicInfo ginfo)
{
#if !XBOX
if (skin != null)
{
manager = new Manager(engine, skin, ginfo.Window);
}
else
{
manager = new Manager(engine, ginfo.Window);
}
#else
if (skin != null)
{
manager = new Manager(engine, skin);
}
else
{
manager = new Manager(engine);
}
#endif
if (skin != null)
{
Manager.SkinDirectory = @"Content\";
}
else
{
Manager.SkinDirectory = @"Content\Skins";
}
manager.Initialize();
}
public void Initialization(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, SceneControl.IObject obj)
{
//Add the normal texture to the shader
TerrainShader.Parameters["NormalTexture"].SetValue(QuadTerrain.globalNormalTexture);
//Set the Global Scale (used for the normal and blending textures) value in the shader.
TerrainShader.Parameters["globalScale"].SetValue(QuadTerrain.flatScale * QuadTerrain.TerrainHeight);
}
/// <summary>
/// Initializes this instance.
/// </summary>
/// <param name="ginfo"></param>
/// <param name="factory"></param>
/// <param name="obj"></param>
public override void Initialize(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, IObject obj)
{
base.Initialize(ginfo, factory, obj);
this._shader = factory.GetEffect("RenderGBuffer", true, true);
ViewProjectionParameter = this._shader.Parameters["ViewProjection"];
//TextureParameter = this._shader.Parameters["Texture"];
IdParameter = this._shader.Parameters["id"];
SpecularIntensityParameter = this._shader.Parameters["specularIntensity"];
SpecularPowerParameter = this._shader.Parameters["specularPower"];
WorldParameter = this._shader.Parameters["World"];
//PAmbientCubeTexture = this._shader.Parameters["ambientcube"];
PAmbientCubeMapScale = this._shader.Parameters["ambientScale"];
if (useAmbientCubeMap == true)
{
this._shader.CurrentTechnique = this._shader.Techniques["Technique2"];
}
else
{
this._shader.CurrentTechnique = this._shader.Techniques["Technique1"];
}
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
depht = factory.GetEffect("depth", false, true);
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color,
ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
be = new GaussianBlurPostEffect();
be.Init(ginfo, factory);
}
public void LoadContent(IContentManager manager, Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, Color BackGroundColor, bool useFloatBuffer)
{
this.useFloatBuffer = useFloatBuffer;
normalRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, false, DepthFormat.Depth24, 0, RenderTargetUsage.DiscardContents);
depthRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Single, false, DepthFormat.Depth24, 0, RenderTargetUsage.DiscardContents);
//lightOclusionRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, multisample, RenderTargetUsage.DiscardContents);
clearBufferEffect = manager.GetAsset <Effect>("PrePass2/ClearGBuffer");
}
public void CleanUp(Engine.GraphicFactory factory)
{
foreach (var item in modelNames)
{
factory.ReleaseAsset(item);
}
modelNames.Clear();
}
public void LoadContent(IContentManager manager, Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, bool cullPointLight, bool useFloatingBufferForLightning)
{
_lightAddBlendState = new BlendState()
{
AlphaSourceBlend = Blend.One,
ColorSourceBlend = Blend.One,
AlphaDestinationBlend = Blend.One,
ColorDestinationBlend = Blend.One,
};
this.ginfo = ginfo;
this.cullPointLight = cullPointLight;
if (useFloatingBufferForLightning)
{
lightRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.HdrBlendable, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample, RenderTargetUsage.DiscardContents);
samplerState = SamplerState.PointClamp;
}
else
{
lightRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample, RenderTargetUsage.DiscardContents);
samplerState = ginfo.SamplerState;
}
directionalLightEffect = manager.GetAsset <Effect>("DirectionalLight", true);
pointLightEffect = manager.GetAsset <Effect>("PointLight", true);
sphereModel = new SimpleModel(factory, "Dsphere", true);
spotLightEffect = manager.GetAsset <Effect>("SpotLight", true);
spotLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
pointLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
//DirectionalcolorMap = directionalLightEffect.Parameters["colorMap"];
//DirectionalnormalMap = directionalLightEffect.Parameters["normalMap"];
//DirectionaldepthMap = directionalLightEffect.Parameters["depthMap"];
DirectionalInvertViewProjection = directionalLightEffect.Parameters["InvertViewProjection"];
DirectionalhalfPixel = directionalLightEffect.Parameters["halfPixel"];
DirectionalcameraPosition = directionalLightEffect.Parameters["cameraPosition"];
DirectionallightDirection = directionalLightEffect.Parameters["lightDirection"];
DirectionalColor = directionalLightEffect.Parameters["Color"];
DirectionallightIntensity = directionalLightEffect.Parameters["lightIntensity"];
//PointcolorMap = pointLightEffect.Parameters["colorMap"];
//PointnormalMap = pointLightEffect.Parameters["normalMap"];
//PointdepthMap = pointLightEffect.Parameters["depthMap"];
PointProjection = pointLightEffect.Parameters["Projection"];
PointView = pointLightEffect.Parameters["View"];
PointInvertViewProjection = pointLightEffect.Parameters["InvertViewProjection"];
PointWorld = pointLightEffect.Parameters["World"];
PointlightPosition = pointLightEffect.Parameters["lightPosition"];
PointColor = pointLightEffect.Parameters["Color"];
PointlightRadius = pointLightEffect.Parameters["lightRadius"];
PointlightIntensity = pointLightEffect.Parameters["lightIntensity"];
Pointquadratic = pointLightEffect.Parameters["quadratic"];
PointcameraPosition = pointLightEffect.Parameters["cameraPosition"];
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight);
target2 = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight);
effect = factory.GetEffect("glowPost", false, true);
gbp = new GaussianBlurPostEffect();
gbp.Init(ginfo, factory);
}
public void Initialize(Engine.GraphicFactory factory, Engine.GraphicInfo ginfo)
{
if (DebugBox.effect == null)
{
DebugBox.effect = factory.GetBasicEffect();
DebugBox.effect.VertexColorEnabled = true;
DebugBox.effect.LightingEnabled = false;
DebugBox.effect.TextureEnabled = false;
}
}
public ModelLoaderData Load(Engine.GraphicFactory factory, Engine.GraphicInfo info, string Name)
{
modelNames.Add(Name);
ModelLoaderData ModelLoaderData = new ModelLoaderData();
Model model = factory.GetModel(Name);
Matrix[] m = new Matrix[model.Bones.Count];
model.CopyAbsoluteBoneTransformsTo(m);
for (int i = 0; i < model.Meshes.Count; i++)
{
String name = model.Meshes[i].Name.Substring(5);
for (int j = 0; j < model.Meshes[i].MeshParts.Count; j++)
{
Matrix tr = m[model.Meshes[i].ParentBone.Index];
Vector3 scale;
Vector3 pos;
Quaternion ori;
tr.Decompose(out scale, out ori, out pos);
ObjectInformation mi = new ObjectInformation();
mi.modelName = name;
mi.meshPartIndex = j;
mi.meshIndex = i;
mi.position = pos;
mi.scale = scale;
mi.rotation = ori;
mi.ellasticity = -1;
mi.dinamicfriction = -1;
mi.staticfriction = -1;
mi.collisionType = "TriangleMesh";
mi.mass = 10;
ModelBuilderHelper.Extract(m, model.Meshes[i].MeshParts[j], out mi.batchInformation);
mi.batchInformation.ModelLocalTransformation = m[model.Meshes[i].ParentBone.Index];
mi.textureInformation = new Modelo.TextureInformation(false, factory, null, null, null, null);
mi.textureInformation.LoadTexture();
Effect effect = model.Meshes[i].MeshParts[j].Effect;
BasicEffect BasicEffect = effect as BasicEffect;
if (BasicEffect != null)
{
mi.textureInformation.SetTexture(BasicEffect.Texture, TextureType.DIFFUSE);
}
ModelLoaderData.ModelMeshesInfo.Add(mi);
}
}
return(ModelLoaderData);
}
public void LoadContent(IContentManager manager, Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, bool cullPointLight, bool useFloatingBufferForLightning)
{
_lightAddBlendState = new BlendState()
{
AlphaSourceBlend = Blend.One,
ColorSourceBlend = Blend.One,
AlphaDestinationBlend = Blend.One,
ColorDestinationBlend = Blend.One,
};
this.ginfo = ginfo;
shadow = new DirectionalShadowRenderer();
shadow.ShadowFilteringType = filteringType;
shadow.ShadowMapSize = shadowMapSize;
shadow.SplitConstant = splitConstant;
shadownBufferSize = ginfo.BackBufferWidth;
shadowRT = factory.CreateRenderTarget(shadownBufferSize, shadownBufferSize, SurfaceFormat.Single, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, ginfo.MultiSample);
if (useFloatingBufferForLightning)
{
lightRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.HdrBlendable, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample, RenderTargetUsage.PreserveContents);
}
else
{
lightRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample, RenderTargetUsage.PreserveContents);
}
pointLightEffect = factory.GetEffect("PointLight", false, true);
directionalLightEffect = factory.GetEffect("ShadowDirectionalCascade", false, true);
spotLightEffect = factory.GetEffect("ShadowSpot", false, true);
sphereModel = new SimpleModel(factory, "Dsphere", true);
blank = factory.CreateTexture2DColor(1, 1, Color.White);
rt = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, ginfo.MultiSample);
deferredRT = factory.CreateRenderTarget(shadownBufferSize, shadownBufferSize, SurfaceFormat.Single, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, ginfo.MultiSample);
shadow.Load(factory, ginfo);
switch (shadowFilterSpot)
{
case ShadowFilter.NONE:
spotLightEffect.CurrentTechnique = spotLightEffect.Techniques["Technique1"];
break;
case ShadowFilter.PCF3x3:
spotLightEffect.CurrentTechnique = spotLightEffect.Techniques["Technique2"];
break;
case ShadowFilter.PCF7x7SOFT:
spotLightEffect.CurrentTechnique = spotLightEffect.Techniques["Technique3"];
break;
default:
break;
}
}
public void LoadContent(IContentManager manager, Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, Color BackGroundColor, bool useFloatBuffer)
{
this.backGroundColor = BackGroundColor;
colorRT2 = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, 8, RenderTargetUsage.DiscardContents);
colorRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.DiscardContents);
normalRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, 0, RenderTargetUsage.DiscardContents);
depthRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Single, ginfo.UseMipMap, DepthFormat.None, 0, RenderTargetUsage.DiscardContents);
lightOclusionRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, 0, RenderTargetUsage.DiscardContents);
clearBufferEffect = manager.GetAsset <Effect>("ClearGBuffer", true);
effect = factory.GetEffect("Effects//hibe");
}
public override void Initialize(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, IObject obj)
{
base.Initialize(ginfo, factory, obj);
this._shader = factory.GetEffect("AnimatedBillboard", false, true);
this.aniTex = obj.Modelo.getTexture(TextureType.DIFFUSE, 0, 0);
obj.Modelo.GetTextureInformation(0)[0].OnTextureChange += new OnTextureChange(Modelo_OnTextureChange);
totalwidth = aniTex.Width;
this.width = aniTex.Width / numberOfFrames;
this.height = aniTex.Height;
size = width / totalwidth;
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
Saturate = factory.GetEffect("Saturate", false, true);
Saturate.Parameters["BloomThreshold"].SetValue(bloomThreshold);
Combine = factory.GetEffect("Combine", false, true);
renderTarget0 = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
renderTarget1 = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
gaussian = new GaussianBlurPostEffect();
gaussian.Init(ginfo, factory);
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
effect = factory.GetEffect("Sun", false, true);
if (flareTexture == null)
{
tex = factory.GetTexture2D("flare", true);
}
else
{
tex = factory.GetTexture2D(flareTexture);
}
}
/// <summary>
/// Initializes
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="ginfo">The ginfo.</param>
public void Initialize(Engine.GraphicFactory factory, Engine.GraphicInfo ginfo)
{
sphereModel = new SimpleModel(factory, "Dsphere", true);
if (effect == null)
{
effect = factory.GetBasicEffect();
effect.TextureEnabled = false;
effect.VertexColorEnabled = false;
effect.LightingEnabled = lightingEnabled;
WireFrameEnabled = true;
}
}
/// <summary>
/// Initializes this instance.
/// </summary>
/// <param name="ginfo"></param>
/// <param name="factory"></param>
/// <param name="obj"></param>
public override void Initialize(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, IObject obj)
{
this._shader = factory.GetEffect("EMSHADER", true, true);
if (texCube == null)
{
texCube = factory.GetTextureCube(texName, false);
}
base.Initialize(ginfo, factory, obj);
}
public override void Initialize(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, IObject obj)
{
base.Initialize(ginfo, factory, obj);
this.ginfo = ginfo;
this._shader = factory.GetEffect("Terrain", true, true);
if (terrainType == TerrainType.SINGLETEXTURE)
{
this._shader.CurrentTechnique = this._shader.Techniques["Technique1"];
}
else
{
this._shader.CurrentTechnique = this._shader.Techniques["MultiTexture"];
}
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
target2 = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
target3 = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
effect = factory.GetEffect("SSAOPOST", false, true);
ssaofinal = factory.GetEffect("ssaofinal", false, true);
RandomTexture = factory.GetTexture2D("random", true);
gbp = new GaussianBlurPostEffect();
gbp.Init(ginfo, factory);
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
spriteBatch = factory.GetSpriteBatch();
GraphicsDevice GraphicsDevice = factory.device;
PresentationParameters pp = GraphicsDevice.PresentationParameters;
int w = pp.BackBufferWidth;
int h = pp.BackBufferHeight;
scene = new RenderTarget2D(GraphicsDevice, w, h, false, pp.BackBufferFormat, pp.DepthStencilFormat, pp.MultiSampleCount, RenderTargetUsage.DiscardContents);
halfSize = new RenderTarget2D(GraphicsDevice, w / 2, h / 2, false, pp.BackBufferFormat, DepthFormat.None);
quarterSize = new RenderTarget2D(GraphicsDevice, w / 4, h / 4, false, pp.BackBufferFormat, DepthFormat.None);
quarterSize2 = new RenderTarget2D(GraphicsDevice, w / 4, h / 4, false, pp.BackBufferFormat, DepthFormat.None);
}
public void LoadContent(IContentManager manager, Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, Color BackGroundColor, bool useFloatBuffer)
{
this.useFloatBuffer = useFloatBuffer;
this.backGroundColor = BackGroundColor;
const int multisample = 0;
colorRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, multisample, RenderTargetUsage.DiscardContents);
normalRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, multisample, RenderTargetUsage.DiscardContents);
depthRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Single, ginfo.UseMipMap, DepthFormat.None, multisample, RenderTargetUsage.DiscardContents);
lightOclusionRT = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, multisample, RenderTargetUsage.DiscardContents);
clearBufferEffect = manager.GetAsset <Effect>("ClearGBuffer", true);
clearBufferEffect.Parameters["BackColor"].SetValue(backGroundColor.ToVector3());
}
public void LoadContent(IContentManager manager, Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, bool useFloatBuffer, bool saveToTexture)
{
this.useFloatBuffer = useFloatBuffer;
this.ginfo = ginfo;
this.saveToTexture = saveToTexture;
effect = factory.GetEffect("Effects//hibe");
finalCombineEffect = manager.GetAsset <Effect>("CombineFinal", true);
if (saveToTexture)
{
//if (useFloatBuffer)
// target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.HdrBlendable, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample, RenderTargetUsage.DiscardContents);
//else
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample, RenderTargetUsage.DiscardContents);
}
half = ginfo.HalfPixel;
}
public override void Init(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
gblur = factory.GetEffect("gblur", true, true);
if (useHalfSingleRenderTarget)
{
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Single, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
}
else
{
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.None, ginfo.MultiSample);
}
Vector2 texelSize = new Vector2(1f / ginfo.BackBufferWidth, 1f / ginfo.BackBufferHeight);
SetBlurParameters(texelSize.X, 0, ref sampleOffsetsH, ref sampleWeightsH);
SetBlurParameters(0, texelSize.Y, ref sampleOffsetsV, ref sampleWeightsV);
}
protected override void LoadContent(Engine.GraphicInfo GraphicInfo, Engine.GraphicFactory factory)
{
this.factory = factory;
this.GraphicInfo = GraphicInfo;
base.LoadContent(GraphicInfo, factory);
}
