public ShaderInvisibilidad(Device d3dDevice, string ShadersDir)
{
D3DDevice = d3dDevice;
//Shader Invisibilidad
Invisibilidad = TGCShaders.Instance.LoadEffect(ShadersDir + "\\Invisibilidad.fx");
Invisibilidad.Technique = "DefaultTechnique";
g_pDepthStencil = d3dDevice.CreateDepthStencilSurface(d3dDevice.PresentationParameters.BackBufferWidth,
d3dDevice.PresentationParameters.BackBufferHeight,
DepthFormat.D24S8, MultiSampleType.None, 0, true);
g_pRenderTarget = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.X8R8G8B8,
Pool.Default);
Invisibilidad.SetValue("g_RenderTarget", g_pRenderTarget);
// Resolucion de pantalla
Invisibilidad.SetValue("screen_dx", d3dDevice.PresentationParameters.BackBufferWidth);
Invisibilidad.SetValue("screen_dy", d3dDevice.PresentationParameters.BackBufferHeight);
CustomVertex.PositionTextured[] vertices =
{
new CustomVertex.PositionTextured(-1, 1, 1, 0, 0),
new CustomVertex.PositionTextured(1, 1, 1, 1, 0),
new CustomVertex.PositionTextured(-1, -1, 1, 0, 1),
new CustomVertex.PositionTextured(1, -1, 1, 1, 1)
};
//Vertex buffer de los triangulos
g_pVBV3D = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, d3dDevice, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
g_pVBV3D.SetData(vertices, 0, LockFlags.None);
}
public void renderFull(int w, int h)
{
Vector4 v = new Vector4(0, 0, (float)w, (float)h);
mShader.SetValue(m_fxViewport, v);
Vector4 v2 = new Vector4(0, 0, 0, 0);
mShader.SetValue(m_fxDestRegionCoord, v2);
Vector4 v3 = new Vector4((float)w, (float)h, 0, 0);
mShader.SetValue(m_fxDestRegionSize, v3);
Vector4 v4 = new Vector4(1.0f / (float)w, 1.0f / (float)h, 0, 0);
mShader.SetValue(m_fxInvDestRegionSize, v4);
Viewport vp = new Viewport();
vp.X = 0;
vp.Y = 0;
vp.Width = w;
vp.Height = h;
vp.MinZ = 0;
vp.MaxZ = 1;
BRenderDevice.getDevice().Viewport = vp;
mShader.CommitChanges();
BRenderDevice.beginScene();
mShader.Begin(FX.DoNotSaveState | FX.DoNotSaveShaderState | FX.DoNotSaveSamplerState);
mShader.BeginPass(0);
s_Quad.render();
mShader.EndPass();
mShader.End();
BRenderDevice.endScene();
}
public override void Update()
{
PreUpdate();
try
{
hotReloadEffect.Update(ElapsedTime);
effect = hotReloadEffect.Effect;
effect.Technique = "Default";
effect.SetValue("time", time);
effect.SetValue("textureExample", texture.D3dTexture);
effect.SetValue("screenWidth", D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth);
effect.SetValue("screenHeight", D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
if (Input.keyDown(Key.A))
{
D3DDevice.Instance.Device.RenderState.FillMode = FillMode.WireFrame;
}
else
{
D3DDevice.Instance.Device.RenderState.FillMode = FillMode.Solid;
}
time += ElapsedTime;
PostUpdate();
}
public void DrawGoo()
{
float CurrTime = DXUtil.Timer(DirectXTimer.GetApplicationTime);
float fTime = (float)(((CurrTime % 180.0f) / 180.0f) * (2 * Math.PI));
WorldMatrix = DirectX.Matrix.RotationYawPitchRoll((float)((CurrTime % 240) / 240 * Math.PI), 0, 0) * DirectX.Matrix.Translation(0, -45, -400);
DirectX.Matrix WorldViewMatrix = WorldMatrix * ViewMatrix;
DirectX.Matrix WorldViewProjMatrix = WorldMatrix * ViewMatrix * ProjectionMatrix;
GooEffect.SetValue("fMixTime", fTime);
GooEffect.SetValue("WorldView", WorldViewMatrix);
GooEffect.SetValue("WorldViewProjection", WorldViewProjMatrix);
GameDevice.RenderState.AlphaBlendEnable = false;
int numPasses = GooEffect.Begin(0);
for (int i = 0; i < numPasses; i++)
{
GooEffect.BeginPass(i);
GooMesh.DrawSubset(0);
GooEffect.EndPass();
}
GooEffect.End();
// Restore alpha blend setting
GameDevice.RenderState.AlphaBlendEnable = true;
}
private void drawPostProcess(float elapsedTime, bool activado)
{
//Arrancamos la escena
D3DDevice.Instance.Device.BeginScene();
//Cargamos para renderizar el unico modelo que tenemos, un Quad que ocupa toda la pantalla, con la textura de todo lo dibujado antes
D3DDevice.Instance.Device.VertexFormat = CustomVertex.PositionTextured.Format;
D3DDevice.Instance.Device.SetStreamSource(0, screenQuadVB, 0);
//Ver si el efecto de alarma esta activado, configurar Technique del shader segun corresponda
if (activado)
{
efecto.Technique = "AlarmaTechnique";
}
else
{
efecto.Technique = "DefaultTechnique";
}
//Cargamos parametros en el shader de Post-Procesado
efecto.SetValue("render_target2D", renderTarget2D);
efecto.SetValue("textura_alarma", alarmTexture.D3dTexture);
efecto.SetValue("alarmaScaleFactor", intVaivenAlarm.update(elapsedTime));
//Limiamos la pantalla y ejecutamos el render del shader
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
efecto.Begin(FX.None);
efecto.BeginPass(0);
D3DDevice.Instance.Device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
efecto.EndPass();
efecto.End();
D3DDevice.Instance.Device.EndScene();
D3DDevice.Instance.Device.Present();
}
public void loadEffectWithFogValues(Effect effect)
{
effect.SetValue("ColorFog", fog.Color.ToArgb());
//effect.SetValue("CameraPos", TGCVector3.TGCVector3ToFloat4Array(Camera.Position));
effect.SetValue("StartFogDistance", fog.StartDistance);
effect.SetValue("EndFogDistance", fog.EndDistance);
}
public void efectoSombra(TGCVector3 lightDir, TGCVector3 lightPos, TGCMatrix lightView, TGCMatrix projMatrix)
{
efecto.SetValue("g_vLightPos", new Vector4(lightPos.X, lightPos.Y, lightPos.Z, 1));
efecto.SetValue("g_vLightDir", new Vector4(lightDir.X, lightDir.Y, lightDir.Z, 1));
efecto.SetValue("g_mProjLight", projMatrix.ToMatrix());
efecto.SetValue("g_mViewLightProj", (lightView * projMatrix).ToMatrix());
}
public void SetColor(Dx3D.Effect shader, Color color)
{
if (shader == _LightShader)
{
shader.SetValue("materialAmbientColor", ColorValue.FromColor(color));
shader.SetValue("materialDiffuseColor", ColorValue.FromColor(color));
shader.SetValue("materialSpecularColor", ColorValue.FromColor(color));
}
}
public override void Update(float elapsedTime)
{
bulletManager.Update(elapsedTime);
collectModel.Update(elapsedTime);
playerModel.Update(elapsedTime);
skyBox.Center = playerModel.Position;
effect.SetValue("withoutHelmet", playerModel.WithoutHelmet);
effect.SetValue("inWater", playerModel.UnderSurface());
}
public void Render(float elapsedTime)
{
Time += elapsedTime;
rollEffect.SetValue("time", Time);
// Cargar matrices de transformacion:
rollEffect.SetValue("matWorld", D3DDevice.Instance.Device.Transform.World);
rollEffect.SetValue("matWorldView", D3DDevice.Instance.Device.Transform.World *
D3DDevice.Instance.Device.Transform.View);
rollEffect.SetValue("matWorldViewProj", D3DDevice.Instance.Device.Transform.World *
D3DDevice.Instance.Device.Transform.View * D3DDevice.Instance.Device.Transform.Projection);
this.ship.Render();
}
private void AplicarShaders(String shaderDir)
{
efectoOlas = TgcShaders.loadEffect(shaderDir + "ShaderOlas.fx");
foreach (TgcMesh mesh in aguas)
{
mesh.Effect = efectoOlas;
mesh.Technique = "Olas";
}
efectoOlas.SetValue("screen_dx", resolucionX);
efectoOlas.SetValue("screen_dy", resolucionY);
}
unsafe public void clearJacobianMap()
{
if (m_fxJacobian == null)// || mSynthesiser == null)
{
return;
}
Vector4 tr = new Vector4(0, 0, (float)m_iBuffersWidth, (float)m_iBuffersHeight);
// save render target
D3DProtectRenderTarget locktarget = new D3DProtectRenderTarget(true);
// set new render target
BRenderDevice.getDevice().SetRenderTarget(0, mJacobianMapSrf);
BRenderDevice.getDevice().SetRenderTarget(1, mJacobianMapInverseSrf);
savedDepthSten = BRenderDevice.getDevice().DepthStencilSurface;
BRenderDevice.getDevice().DepthStencilSurface = m_DepthStencilSurface;
// render
BRenderDevice.getDevice().BeginScene();
{
BRenderDevice.getDevice().Clear(ClearFlags.Target, Color.Black, 1, 0);
m_fxJacobian.Technique = m_fxJacobianClearTech;
m_fxJacobian.SetValue(m_fxJacobianGlobalScale, mExemplar == null?0:mExemplar.mSynthParams.TextureScale);
m_fxJacobian.SetValue(m_fxJacobianSelectedJMap, (int)mJMapPattern);
m_fxJacobian.SetValue(m_fxJacobianViewport, tr);
m_fxJacobian.CommitChanges();
m_fxJacobian.Begin(FX.DoNotSaveState | FX.DoNotSaveShaderState | FX.DoNotSaveSamplerState);
m_fxJacobian.BeginPass(0);
m_QuadDual.render();
m_fxJacobian.EndPass();
m_fxJacobian.End();
BRenderDevice.getDevice().EndScene();
}
m_bNeedUpdate = true;
BRenderDevice.getDevice().DepthStencilSurface = savedDepthSten;
savedDepthSten.Dispose();
savedDepthSten = null;
BRenderDevice.getDevice().SetRenderTarget(1, null);
BRenderDevice.getDevice().SetTexture(0, null);
locktarget.destroy();
locktarget = null;
// BRenderDevice.writeTextureToFile(mJacobianMap, AppDomain.CurrentDomain.BaseDirectory + "screens\\localFrames.bmp");
// BRenderDevice.writeTextureToFile(mJacobianMapInverse, AppDomain.CurrentDomain.BaseDirectory + "screens\\localFramesINV.bmp");
}
private void AplicarShaders(String shaderDir)
{
efectoOlas = TgcShaders.loadEffect(shaderDir + "ShaderOlas.fx");
efectoTeleport = TgcShaders.loadEffect(shaderDir + "RobotRoomChange.fx");
foreach (TgcMesh mesh in dangerPlaces)
{
mesh.Effect = efectoOlas;
mesh.Technique = "Olas";
}
efectoOlas.SetValue("screen_dx", resolucionX);
efectoOlas.SetValue("screen_dy", resolucionY);
}
private void UpdateGame()
{
//Capturar Input teclado
RevisarLockeoMouse();
if (personaje.LockMouse)
{
if (!perdi)
{
UpdateAccionesDeMovimientoYCamara();
}
if (Input.keyDown(Key.E))
{
InteraccionPersonajeYMesh();
}
ReproducirSonidoRandomEscenario();
reproducirRandomDeLista(monster.getSoundList());
RealizarAccionesDeInventario();
personaje.updateCamera(ElapsedTime, Input);
personaje.aumentarTiempoSinLuz();
if (personaje.tieneLuz)
{
personaje.itemEnMano.DisminuirDuracion(personaje);
}
AccionesPersonajeMonstruo();
}
timer += ElapsedTime;
var d3dDevice = D3DDevice.Instance.Device;
effectPosProcesado.SetValue("eyePosition", TGCVector3.TGCVector3ToFloat3Array(personaje.Position));
effectPosProcesado.SetValue("screenWidth", d3dDevice.PresentationParameters.BackBufferWidth);
effectPosProcesado.SetValue("screenHeight", d3dDevice.PresentationParameters.BackBufferHeight);
effectPosProcesado.SetValue("timer", timer);
if (renderizado is MonsterBlur)
{
monsterBlur.UpdateMonsterBlur(ElapsedTime, monster);
}
}
private void AplicarShaderChoque()
{
/* INICIO CHOQUE */
if (this.colisionoAlgunaVez && this.getMesh().Position.Y == 5)
{
ChoqueDelantero = 1;
}
if (this.colisiono() && !this.colisionoAlgunaVez && this.getMesh().Position.Y == 5)
{
ChoqueTrasero = -1;
}
if (this.colisiono() && this.getMesh().Position.Y == 5)
{
ChoqueDelantero = 1;
}
float vida = base.getLifeLevel().nivelDeVida();
int energia = 10;
if (vida < 100)
{
if (vida < 40)
{
if (vida < 20)
{
energia = 2;
}
else
{
energia = 4;
}
}
else
{
if (vida < 70)
{
energia = 7;
}
}
}
efectoShaderChoque.SetValue("Energia", energia);
efectoShaderChoque.SetValue("ChoqueAtras", ChoqueTrasero);
efectoShaderChoque.SetValue("ChoqueAdelante", ChoqueDelantero);
efectoShaderChoque.SetValue("fvLightPosition", new Vector4(0, 100, 0, 0));
efectoShaderChoque.SetValue("fvEyePosition", TgcParserUtils.vector3ToFloat3Array(this.getCamara().Position));
this.getMesh().Effect = efectoShaderChoque;
this.getMesh().Technique = "RenderScene";
}
public void setShadersValues()
{
Vector3 lightPosition = new Vector3(-100, 140, 3000);// (Vector3)GuiController.Instance.Modifiers["LightPosition"];
efectoOlas.SetValue("llueve", (Boolean)GuiController.Instance.Modifiers["lluvia"]);
efectoOlas.SetValue("time", (float)GuiController.Instance.UserVars.getValue("time"));
efectoOlas.SetValue("fvLightPosition", TgcParserUtils.vector3ToFloat3Array(lightPosition));
efectoOlas.SetValue("k_la", (float)GuiController.Instance.Modifiers["Ambient"]);
efectoOlas.SetValue("fSpecularPower", 20.0f);//(float)GuiController.Instance.Modifiers["SpecularPower"]); efectoOlas.SetValue("blendAmount", (float)GuiController.Instance.Modifiers["blending"]);
efectoOlas.SetValue("fvEyePosition", TgcParserUtils.vector3ToFloat3Array(GuiController.Instance.CurrentCamera.getPosition()));
efectoOlas.SetValue("fogColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["fog color"]));
efectoOlas.SetValue("fogStart", (float)GuiController.Instance.Modifiers["fog start"]);
efectoOlas.SetValue("blendStart", (float)GuiController.Instance.Modifiers["blend start"]);
efectoOlas.SetValue("camara3p", (Boolean)GuiController.Instance.Modifiers["camaraEnBarco"]);
efectoOlas.SetValue("rayo", rayo);
efectoOlas.SetValue("delta", 150.0f);//(float)GuiController.Instance.Modifiers["delta"]); efectoOlas.SetValue("reflection", (float)GuiController.Instance.Modifiers["reflection"]);
//CubeMap
efectoOlas.SetValue("texCubeMap", cubeMap);
efectoCascada.SetValue("time", (float)GuiController.Instance.UserVars.getValue("time"));
efectoCascada.SetValue("fvEyePosition", TgcParserUtils.vector3ToFloat3Array(GuiController.Instance.CurrentCamera.getPosition()));
efectoCascada.SetValue("fvLightPosition", TgcParserUtils.vector3ToFloat3Array(lightPosition));
efectoCascada.SetValue("camara3p", (Boolean)GuiController.Instance.Modifiers["camaraEnBarco"]);
efectoCascada.SetValue("texCubeMap", cubeMap);
efectoCascada.SetValue("reflection", (float)GuiController.Instance.Modifiers["reflection"]);
efectoCascada.SetValue("blendAmount", (float)GuiController.Instance.Modifiers["blending"]);
efectoCascada.SetValue("k_la", (float)GuiController.Instance.Modifiers["Ambient"]);
}
private void incializarVisionNoctura()
{
var d3dDevice = D3DDevice.Instance.Device;
otroEfecto = TgcShaders.loadEffect(ShadersDir + "GaussianBlur.fx");
//Configurar Technique dentro del shader
otroEfecto.Technique = "DefaultTechnique";
g_pDepthStencil = d3dDevice.CreateDepthStencilSurface(d3dDevice.PresentationParameters.BackBufferWidth,
d3dDevice.PresentationParameters.BackBufferHeight,
DepthFormat.D24S8, MultiSampleType.None, 0, true);
// inicializo el render target
g_pRenderTarget = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
g_pGlowMap = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
g_pRenderTarget4 = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth / 4
, d3dDevice.PresentationParameters.BackBufferHeight / 4, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
g_pRenderTarget4Aux = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth / 4
, d3dDevice.PresentationParameters.BackBufferHeight / 4, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
otroEfecto.SetValue("g_RenderTarget", g_pRenderTarget);
// Resolucion de pantalla
otroEfecto.SetValue("screen_dx", d3dDevice.PresentationParameters.BackBufferWidth);
otroEfecto.SetValue("screen_dy", d3dDevice.PresentationParameters.BackBufferHeight);
CustomVertex.PositionTextured[] vertices =
{
new CustomVertex.PositionTextured(-1, 1, 1, 0, 0),
new CustomVertex.PositionTextured(1, 1, 1, 1, 0),
new CustomVertex.PositionTextured(-1, -1, 1, 0, 1),
new CustomVertex.PositionTextured(1, -1, 1, 1, 1)
};
//vertex buffer de los triangulos
g_pVBV3D = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, d3dDevice, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
g_pVBV3D.SetData(vertices, 0, LockFlags.None);
}
private void LoadShaders()
{
var d3dDevice = D3DDevice.Instance.Device;
//Cargar Shader personalizado
string compilationErrors;
effect = Effect.FromFile(d3dDevice, ShadersDir + "\\PostProcess.fx", null, null, ShaderFlags.PreferFlowControl,
null, out compilationErrors);
if (effect == null)
{
throw new Exception("Error al cargar shader. Errores: " + compilationErrors);
}
//Configurar Technique dentro del shader
effect.Technique = "PostProcess";
g_pDepthStencil = d3dDevice.CreateDepthStencilSurface(d3dDevice.PresentationParameters.BackBufferWidth,
d3dDevice.PresentationParameters.BackBufferHeight,
DepthFormat.D24S8, MultiSampleType.None, 0, true);
// inicializo el render target
g_pRenderTarget = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.X8R8G8B8,
Pool.Default);
effect.SetValue("g_RenderTarget", g_pRenderTarget);
// Resolucion de pantalla
effect.SetValue("screen_dx", d3dDevice.PresentationParameters.BackBufferWidth);
effect.SetValue("screen_dy", d3dDevice.PresentationParameters.BackBufferHeight);
var texturaCasco = TgcTexture.createTexture(MediaDir + "Level1\\Textures\\mask.png");
effect.SetValue("texCasco", texturaCasco.D3dTexture);
CustomVertex.PositionTextured[] vertices =
{
new CustomVertex.PositionTextured(-1, 1, 1, 0, 0),
new CustomVertex.PositionTextured(1, 1, 1, 1, 0),
new CustomVertex.PositionTextured(-1, -1, 1, 0, 1),
new CustomVertex.PositionTextured(1, -1, 1, 1, 1)
};
//vertex buffer de los triangulos
g_pVBV3D = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, d3dDevice, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
g_pVBV3D.SetData(vertices, 0, LockFlags.None);
}
public GooAccess(Direct3D.Device NewGameDevice,
GameEngine.ShaderLevel NewCardShaderLevel,
DirectX.Matrix NewViewMatrix,
DirectX.Matrix NewProjectionMatrix)
{
GameDevice = NewGameDevice;
CardShaderLevel = NewCardShaderLevel;
ViewMatrix = NewViewMatrix;
ProjectionMatrix = NewProjectionMatrix;
// Load Shader Effect From File
GooEffect = Direct3D.Effect.FromFile(GameDevice, GameConfig.Files.GooFx, null, null, Direct3D.ShaderFlags.None, null);
// Choose shader technique based on shader level.
if (CardShaderLevel == GameEngine.ShaderLevel.Pixel_3_0)
{
GooEffect.Technique = "Goo_Parallax_3_0";
}
else if (CardShaderLevel == GameEngine.ShaderLevel.Pixel_2_b)
{
GooEffect.Technique = "Goo_Parallax_2_b";
}
else if (CardShaderLevel == GameEngine.ShaderLevel.Pixel_2_0)
{
GooEffect.Technique = "Goo_Parallax_2";
}
else if (CardShaderLevel == GameEngine.ShaderLevel.Pixel_1_4)
{
GooEffect.Technique = "Goo_Bump_1_4";
}
// Load Mesh From File
GooMesh = Direct3D.Mesh.FromFile(GameConfig.Files.GooMesh, Direct3D.MeshFlags.Managed, GameDevice);
// Load Textures From File
ColorTexture = Direct3D.TextureLoader.FromFile(GameDevice, GameConfig.Files.GooColor);
NormalTexture = Direct3D.TextureLoader.FromFile(GameDevice, GameConfig.Files.GooNormal);
HeightTexture = Direct3D.TextureLoader.FromFile(GameDevice, GameConfig.Files.GooHeight);
// Load Textures into Effect
GooEffect.SetValue("ColorTexture", ColorTexture);
GooEffect.SetValue("NormalsTexture", NormalTexture);
GooEffect.SetValue("HeightTexture", HeightTexture);
// Set Parallax and Bump Intensity
GooEffect.SetValue("ParallaxAmount", .5f);
GooEffect.SetValue("BumpAmount", 1.5f);
}
private void InitGogleViewEffectResources()
{
gogleViewEffect = TGCShaders.Instance.LoadEffect(ShadersDir + "Varios.fx");
gogleViewTexture = TgcTexture.createTexture(MediaDir + "gogleView.png").D3dTexture;
gogleViewEffect.SetValue("gogleViewTexture", gogleViewTexture);
}
public void PostProcess(Texture render)
{
var d3dDevice = D3DDevice.Instance.Device;
//Arrancamos la escena
d3dDevice.BeginScene();
d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
//Cargamos parametros en el shader de Post-Procesado
effect.SetValue("texDiffuseMap", render);
effect.SetValue("texBloom", renderTargetBloom);
effect.SetValue("activo", Input.keyDown(Key.B)); // Para debugear nomas
d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
screenQuad.render(effect);
}
private void RenderPostProcess()
{
D3DDevice.Instance.Device.BeginScene();
D3DDevice.Instance.Device.VertexFormat = CustomVertex.PositionTextured.Format;
D3DDevice.Instance.Device.SetStreamSource(0, fullQuadVertexBuffer, 0);
gogleViewEffect.SetValue("mainSceneTexture", auxRenderTarget);
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, fog.Color, 1.0f, 0);
if (Player.IsSubmerged)
{
gogleViewEffect.Technique = "GogleView";
}
else
{
gogleViewEffect.Technique = "NoGogles";
}
gogleViewEffect.Begin(FX.None);
gogleViewEffect.BeginPass(0);
D3DDevice.Instance.Device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
gogleViewEffect.EndPass();
gogleViewEffect.End();
RenderHUD();
RenderFPS();
RenderAxis();
D3DDevice.Instance.Device.EndScene();
}
private void AplicarShader()
{
if (!EsAutoJugador)
{
return;
}
//efectoShaderNitroHummer.SetValue("time", GameModel.ElapsedTime);
////efectoShaderNitroHummer.SetValue("Velocidad", 4*Velocidad);
//efectoShaderNitroHummer.SetValue("Deformation", DeformationConstant);
//efectoShaderNitroHummer.SetValue("PosX", Mesh.Position.X);
//efectoShaderNitroHummer.SetValue("PosZ", Mesh.Position.Z);
//efectoShaderNitroHummer.SetValue("Largo", largo);
var aux = 0;
if (chocoAdelante && Mesh.Position.Y == 5)
{
aux = 1;
ChoqueDelantero = 1;
}
if (collisionFound && !chocoAdelante && Mesh.Position.Y == 5)
{
aux = -1;
ChoqueTrasero = -1;
}
efectoShaderNitroHummer.SetValue("ChoqueTrasero", ChoqueTrasero);
efectoShaderNitroHummer.SetValue("ChoqueDelantero", ChoqueDelantero);
//adelante 1 atras - 1
//efectoShaderNitroHummer.SetValue("Choco", aux);
//if (Velocidad < 2.5f)
//{
// Mesh.Effect = efectoOriginal;
// Mesh.Technique = TechniqueOriginal;
//}
//else
//{
// Mesh.Effect = efectoShaderNitroHummer;
// Mesh.Technique = "RenderScene";
//}
Mesh.Effect = efectoShaderNitroHummer;
Mesh.Technique = "RenderScene";
}
public static void RenderPostProcesado()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
// Devuelvo el render target original
d3dDevice.SetRenderTarget(0, RenderTargetOriginal);
// Cargo el quad
d3dDevice.VertexFormat = CustomVertex.PositionTextured.Format;
d3dDevice.SetStreamSource(0, ScreenQuad, 0);
// Cargo los parametros al shader
bool activar_efecto = (bool)GuiController.Instance.Modifiers["lluvia"];
if (activar_efecto)
{
float time = (float)GuiController.Instance.UserVars.getValue("time");
Random random = new Random();
int randomNumber = random.Next(0, 10);
if (time % 5 > 4 && randomNumber > 5)
{
Shader.Technique = "RayoTechnique";
}
else
{
Shader.Technique = "DefaultTechnique";
}
}
else
{
Shader.Technique = "DefaultTechnique";
}
//Cargamos parametros en el shader de Post-Procesado
Shader.SetValue("render_target2D", RenderTargetPostprocesado);
Shader.SetValue("scaleFactor", intVaivenOscurecer.update());
// Hago el postprocesado propiamente dicho
d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
Shader.Begin(FX.None);
Shader.BeginPass(0);
d3dDevice.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
Shader.EndPass();
Shader.End();
}
public void SetAlpha(Dx3D.Effect shader, Single alpha)
{
if (shader == _LightShader)
{
var color = shader.GetValueColor(shader.GetParameter(null, "materialDiffuseColor"));
color.Alpha = alpha;
shader.SetValue("materialDiffuseColor", color);
}
}
public void RenderShadowMap()
{
// Calculo la matriz de view de la luz
shadowEffect.SetValue("g_vLightPos", new Vector4(g_LightPos.X, g_LightPos.Y, g_LightPos.Z, 1));
shadowEffect.SetValue("g_vLightDir", new Vector4(g_LightDir.X, g_LightDir.Y, g_LightDir.Z, 1));
skeletalShadowEffect.SetValue("g_vLightPos", new Vector4(g_LightPos.X, g_LightPos.Y, g_LightPos.Z, 1));
skeletalShadowEffect.SetValue("g_vLightDir", new Vector4(g_LightDir.X, g_LightDir.Y, g_LightDir.Z, 1));
g_LightView = TGCMatrix.LookAtLH(g_LightPos, g_LightPos + g_LightDir, new TGCVector3(0, 0, 1));
// inicializacion standard:
shadowEffect.SetValue("g_mProjLight", g_mShadowProj.ToMatrix());
shadowEffect.SetValue("g_mViewLightProj", (g_LightView * g_mShadowProj).ToMatrix());
skeletalShadowEffect.SetValue("g_mProjLight", g_mShadowProj.ToMatrix());
skeletalShadowEffect.SetValue("g_mViewLightProj", (g_LightView * g_mShadowProj).ToMatrix());
// Primero genero el shadow map, para ello dibujo desde el pto de vista de luz
// a una textura, con el VS y PS que generan un mapa de profundidades.
var pOldRT = D3DDevice.Instance.Device.GetRenderTarget(0);
var pShadowSurf = g_pShadowMap.GetSurfaceLevel(0);
D3DDevice.Instance.Device.SetRenderTarget(0, pShadowSurf);
var pOldDS = D3DDevice.Instance.Device.DepthStencilSurface;
D3DDevice.Instance.Device.DepthStencilSurface = shadowDepthStencil;
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
D3DDevice.Instance.Device.BeginScene();
// Hago el render de la escena pp dicha
shadowEffect.SetValue("g_txShadow", g_pShadowMap);
skeletalShadowEffect.SetValue("g_txShadow", g_pShadowMap);
// RENDER
doingShadowRender = true;
RenderScene();
// Termino
D3DDevice.Instance.Device.EndScene();
//TextureLoader.Save("shadowmap.bmp", ImageFileFormat.Bmp, g_pShadowMap);
// restuaro el render target y el stencil
D3DDevice.Instance.Device.DepthStencilSurface = pOldDS;
D3DDevice.Instance.Device.SetRenderTarget(0, pOldRT);
}
private void InitializeEffect()
{
deferredEffect = TGCShaders.Instance.LoadEffect(ShadersDir + "Deferred.fx");
deferredEffect.SetValue("lightCount", lights.Count);
int index = 0;
lights.ForEach(light =>
{
light.SetLight(index, deferredEffect);
index++;
});
}
/// <summary>
/// Se toma todo lo dibujado antes, que se guardo en una textura, y se le aplica un shader para distorsionar la imagen
/// </summary>
private void drawPostProcess(Microsoft.DirectX.Direct3D.Device d3dDevice)
{
//Arrancamos la escena
d3dDevice.BeginScene();
//Cargamos para renderizar el unico modelo que tenemos, un Quad que ocupa toda la pantalla, con la textura de todo lo dibujado antes
d3dDevice.VertexFormat = CustomVertex.PositionTextured.Format;
d3dDevice.SetStreamSource(0, screenQuadVB, 0);
//Ver si el efecto de oscurecer esta activado, configurar Technique del shader segun corresponda
effect.Technique = "RainTechnique";
if (!presentacion && lloviendo)
{
effect.Technique = "RainTechnique";
}
else
{
effect.Technique = "DefaultTechnique";
}
//Cargamos parametros en el shader de Post-Procesado
effect.SetValue("render_target2D", renderTarget2D);
effect.SetValue("textura_alarma", lluviaTexture.D3dTexture);
effect.SetValue("time", this.ElapsedTime);
//Limiamos la pantalla y ejecutamos el render del shader
d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
effect.Begin(FX.None);
effect.BeginPass(0);
d3dDevice.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.EndPass();
effect.End();
//Terminamos el renderizado de la escena
d3dDevice.EndScene();
d3dDevice.Present();
}
public void Draw(DX.Matrix transform, int pickValue = 0)
{
D3D.Device device = Renderer.current.device;
device.VertexDeclaration = Renderer.current.vtxDeclaration;
device.SetStreamSource(0, vertexBuffer, 0);
Renderer.current.SetValues(usedEffect, transform);
usedEffect.SetValue(Renderer.EffectHandles.PickColor, Renderer.pickIndexToColor(pickValue));
foreach (Subset sub in subsets)
{
float shiftTValue = sub.shiftT >= 11 ? (int)1 << (0x10 - sub.shiftT) : 1.0f / (1 << sub.shiftT);
float shiftSValue = sub.shiftS >= 11 ? (int)1 << (0x10 - sub.shiftS) : 1.0f / (1 << sub.shiftS);
usedEffect.SetValue(Renderer.EffectHandles.ShiftMul, new DX.Vector4(shiftTValue / (float)sub.texture.width, shiftSValue / (float)sub.texture.height, 0, 0));
usedEffect.SetValue(Renderer.EffectHandles.Texture0, sub.texture0);
usedEffect.SetValue(Renderer.EffectHandles.Texture1, sub.texture1);
usedEffect.Begin(D3D.FX.None);
usedEffect.BeginPass(0);
device.Indices = sub.indexBuffer;
device.DrawIndexedPrimitives(D3D.PrimitiveType.TriangleList, 0, 0, vertices.Length, 0, sub.indices.Length / 3);
usedEffect.EndPass();
usedEffect.End();
}
}
/////////////////////////////////////////////////////////////////////////
////////////////////////////////RENDER///////////////////////////////////
/////////////////////////////////////////////////////////////////////////
public void render(float deltaTime, TgcFrustum frustum)
{
foreach (var mesh in objectsInFront)
{
if (!librosAgarrados.Contains(mesh))
{
var resultadoColisionFrustum = TgcCollisionUtils.classifyFrustumAABB(frustum, mesh.BoundingBox);
if (resultadoColisionFrustum != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
mesh.Render();
}
}
}
efectoOlas.SetValue("time", tiempoOlas);
personajePrincipal.animateAndRender(deltaTime);
HUD.Begin(SpriteFlags.AlphaBlend | SpriteFlags.SortDepthFrontToBack);
posVidas = D3DDevice.Instance.Device.Viewport.Width - vida.Width;
for (int i = 0; i < cantVidas; i++)
{
HUD.Transform = TGCMatrix.Translation(new TGCVector3(posVidas, 0, 0));
HUD.Draw(vida.D3dTexture, Rectangle.Empty, Vector3.Empty, Vector3.Empty, Color.OrangeRed);
posVidas -= vida.Width;
}
librosAdquiridos.cambiarTexto(cantidadLibrosAdquiridos.ToString());
librosAdquiridos.cambiarTamañoLetra(28);
librosAdquiridos.cambiarColor(Color.BlueViolet);
librosAdquiridos.Render();
HUD.Draw2D(fisicaLib.D3dTexture, Rectangle.Empty, new SizeF(90, 90), new PointF(D3DDevice.Instance.Width - 95, D3DDevice.Instance.Height - 145), Color.White);
HUD.End();
emisorDeParticulas1.render(deltaTime);
emisorDeParticulas2.render(deltaTime);
emisorDeParticulas3.render(deltaTime);
}
public override void init()
{
//Device de DirectX para crear primitivas
d3dDevice = GuiController.Instance.D3dDevice;
TgcSceneLoader loader = new TgcSceneLoader();
//cargamos los meshes de los barcos
barcoJugador = new BarcoJugador(new Vector3(0, 0, 0), this, GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\Canoa\\Canoa-TgcScene.xml");
barcoIA = new BarcoIA(new Vector3(200, 0, 0), this, GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\Canoa\\Canoa-TgcScene.xml");
string shaderFolder = GuiController.Instance.AlumnoEjemplosMediaDir +"\\shaders";
time = 0;
scaleXZ = 20f;
scaleY = 1.3f;
//cargamos el efecto que le vamos a aplicar a los meshes
effect = TgcShaders.loadEffect(shaderFolder + "\\shaderLoco.fx");
heightmap = GuiController.Instance.AlumnoEjemplosMediaDir + "Heightmap\\" + "heightmap500.jpg";
textura = GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Textures\\Liquidos" + "\\water_flow.jpg";
//cargamos el terreno
terreno = new TgcSimpleTerrain();
terreno.loadHeightmap(heightmap, scaleXZ, scaleY, new Vector3(0, 0, 0));
terreno.loadTexture(textura);
terreno.Effect = effect;
terreno.Technique = "LightScene";
// Creo SkyBox
string texturesPath = GuiController.Instance.ExamplesMediaDir + "Texturas\\Quake\\SkyBox LostAtSeaDay\\";
string skyboxFolder = GuiController.Instance.AlumnoEjemplosMediaDir + "skybox\\";
skyBox = new TgcSkyBox();
skyBox.Center = new Vector3(0, 0, 0);
skyBox.Size = new Vector3(8000, 8000, 8000);
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, skyboxFolder + "skyboxArriba.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, skyboxFolder + "skyboxAbajo.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, skyboxFolder + "skybox2.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, skyboxFolder + "skybox2.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, skyboxFolder + "skybox1.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, skyboxFolder + "skybox2.jpg");
skyBox.SkyEpsilon = 50f;
skyBox.updateValues();
barcoJugador.setEnemy(barcoIA);
barcoJugador.setEffect(effect);
barcoJugador.setTechnique("HeightScene");
barcoIA.setEnemy(barcoJugador);
barcoIA.setEffect(effect);
barcoIA.setTechnique("HeightScene");
barcoJugador.cargarCaniones();
barcoIA.cargarCaniones();
mediaAlturaBarco = barcoJugador.BoundingBox().calculateAxisRadius().Y;
effect.SetValue("mediaAlturaBarco", mediaAlturaBarco);
GuiController.Instance.Modifiers.addFloat("alturaOlas", 5f, 30f, 10f);
GuiController.Instance.Modifiers.addFloat("frecuenciaOlas", 50f, 300f, 100f);
GuiController.Instance.Modifiers.addBoolean("mostrar_lluvia", "Mostrar Lluvia", false);
vecAux = new Vector3(0, 0, 0);
ortogonal = new Vector3(0, 0, 0);
sol = new Sol(effect);
planoSubyacente = new Plano();
normalPlano = new Vector3(0, 0, 0);
terminar = false;
nube = new Nube(1000);
//Centrar camara rotacional respecto a la canoa
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.setCamera(barcoJugador.posicion(), 500, 600);
GuiController.Instance.ThirdPersonCamera.updateCamera();
}
