public FieldRenderInfo(object field, UpdateFieldType type)
{
Field = field;
Type = type;
Name = FieldRenderUtil.GetFriendlyName(field);
FieldRenderUtil.CustomRenderers.TryGetValue(field, out Renderer);
if (Renderer == null)
{
Renderer = FieldRenderUtil.TypeRenderers[(int)Type];
}
Index = Convert.ToUInt32(field);
}
/// <summary>
/// Create test game
/// </summary>
/// <param name="setWindowsTitle">Set windows title</param>
/// <param name="windowWidth">Window width</param>
/// <param name="windowHeight">Window height</param>
/// <param name="setInitCode">Set init code</param>
/// <param name="setUpdateCode">Set update code</param>
/// <param name="setRenderCode">Set render code</param>
protected TestGame(string setWindowsTitle,
int windowWidth, int windowHeight,
RenderHandler setInitCode,
RenderHandler setUpdateCode,
RenderHandler setRenderCode)
: base(setWindowsTitle)
{
/*not required
// Make sure we are in the game directory, unit tests might
// be executed from another directory and then the content files
// will not be found!
Directory.SetCurrentDirectory(Directories.GameBaseDirectory);
*/
#if !XBOX360
if (windowWidth > 0 &&
windowHeight > 0)
{
// Update width and height
this.Window.BeginScreenDeviceChange(false);
this.Window.EndScreenDeviceChange(
this.Window.ScreenDeviceName, windowWidth, windowHeight);
// Make sure our device is changed too (else the resolution
// is not set for our 2d rendering).
this.graphicsManager.PreferredBackBufferWidth = windowWidth;
this.graphicsManager.PreferredBackBufferHeight = windowHeight;
this.graphicsManager.ApplyChanges();
} // if (windowWidth)
#endif
//unused, done in constructor:
//if (String.IsNullOrEmpty(setWindowsTitle) == false)
// this.Window.Title = setWindowsTitle;
//don't show, we got a custom mouse cursor now:
//this.IsMouseVisible = true;
#if !XBOX360
#if DEBUG
WindowsHelper.ForceForegroundWindow(this.Window.Handle.ToInt32());
#endif
#endif
initCode = setInitCode;
updateCode = setUpdateCode;
renderCode = setRenderCode;
}
public VentanaJuego()
{
InitializeComponent();
//this.Width = w;
//this.Height = h;
//pictureBox1.Width = w ;
//pictureBox1.Height = h;
//----------Manager--------------------//
F_M = new FileManager();
R_M = new RenderManager();
S_M = new SceneManager();
PM = new PhisicManager();
//--------Delegados-------------------//
S_H = new SceneHandler(S_M.PlayScene);
R_H = new RenderHandler(R_M.AddData);
F_H = new FileHandler(F_M.GetImg);
//---------Inicializacion------------//
R_M.AddHandlers(S_H, F_H);
//mapa1.SetFileManager(F_H);
mapa1 = F_M.CargarMapa("../../Mapas/mapa3.xml", this.Width, this.Height, 32);
mapa1.IM.left = Keys.A;
mapa1.IM.right = Keys.D;
mapa1.IM.up = Keys.W;
mapa1.IM.down = Keys.S;
mapa1.Draw(R_H);
R_M.Sorting();
//--------Timer--------------------//
//Thread mov = new Thread(Caminar);
//Thread col = new Thread(Colicion);
//mov.Start();
timer1.Start();
//col.Start();
mapa1.FraccPantalla(pictureBox1.Width, pictureBox1.Height);
mapa1.CentrarJugador();
//----------Sonido------------------//
//mp = new MP3Player();
//mp.Open(F_M.GetAud_Path("Correr"));
//mp.Play();
pictureBox1.Refresh();
}
protected virtual bool StartDragging(IDragData dragData, DragOperationsMask mask, int x, int y)
{
return(RenderHandler?.StartDragging(dragData, mask, x, y) ?? false);
}
public void Draw(RenderHandler R_H)
{
foreach(Elemento a in Ele)
{
a.Draw(R_H);
}
}
/// <summary>
/// Dispose of resources (IDisposable implementation)
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (disposing && !disposed)
{
lock (renderSyncObject)
{
render = null;
lock (sharedSyncObject)
{
if (sharedD2DFactory != null && d2DFactory == sharedD2DFactory)
sharedRefCount--;
if (d2DFactory != null && d2DFactory != sharedD2DFactory)
d2DFactory.Dispose();
d2DFactory = null;
if (dwriteFactory != null && dwriteFactory != sharedDwriteFactory)
dwriteFactory.Dispose();
dwriteFactory = null;
if (wicFactory != null && wicFactory != sharedWicFactory)
wicFactory.Dispose();
wicFactory = null;
if (sharedRefCount == 0)
{
if (sharedD2DFactory != null)
sharedD2DFactory.Dispose();
sharedD2DFactory = null;
if (sharedDwriteFactory != null)
sharedDwriteFactory.Dispose();
sharedDwriteFactory = null;
if (sharedWicFactory != null)
sharedWicFactory.Dispose();
sharedWicFactory = null;
}
}
foreach (DrawingShape shape in drawingShapes)
{
shape.Dispose();
}
if (bitmap != null)
bitmap.Dispose();
bitmap = null;
if (dcRenderTarget != null)
dcRenderTarget.Dispose();
dcRenderTarget = null;
if (bitmapRenderTarget != null)
bitmapRenderTarget.Dispose();
bitmapRenderTarget = null;
if (hwndRenderTarget != null)
hwndRenderTarget.Dispose();
hwndRenderTarget = null;
disposed = true;
}
}
base.Dispose(disposing);
}
public virtual void Render(ref Matrix worldMatrix, String techniqueName,
RenderHandler renderDelegate)
{
if (techniqueName == null)
throw new GoblinException("techniqueName is null");
if (renderDelegate == null)
throw new GoblinException("renderDelegate is null");
world.SetValue(worldMatrix);
// Start shader
effect.CurrentTechnique = effect.Techniques[techniqueName];
// Render all passes (usually just one)
//foreach (EffectPass pass in effect.CurrentTechnique.Passes)
for (int num = 0; num < effect.CurrentTechnique.Passes.Count; num++)
{
EffectPass pass = effect.CurrentTechnique.Passes[num];
pass.Apply();
renderDelegate();
}
}
public void DoAction(string s, RenderHandler R_H)
{
Draw(R_H);
}
private void SetRenderMode(RenderModes rm)
{
lock (renderSyncObject)
{
renderMode = rm;
if (!IsInitialized && !isInitializing)
{
return;
}
//clean up objects that will be invalid after RenderTarget change
if (dcRenderTarget != null)
{
dcRenderTarget.Dispose();
dcRenderTarget = null;
}
if (hwndRenderTarget != null)
{
hwndRenderTarget.Dispose();
hwndRenderTarget = null;
}
if (bitmapRenderTarget != null)
{
bitmapRenderTarget.Dispose();
bitmapRenderTarget = null;
}
peelings.Clear();
bitmap = null; //the bitmap created in dc render target can't be used in hwnd render target
// Create the screen render target
var size = new SizeU((uint)ClientSize.Width, (uint)ClientSize.Height);
var props = new RenderTargetProperties
{
PixelFormat = new PixelFormat(
Format.B8G8R8A8UNorm,
AlphaMode.Ignore),
Usage = RenderTargetUsages.GdiCompatible
};
if (renderMode == RenderModes.DCRenderTarget || renderMode == RenderModes.BitmapRenderTargetOnPaint)
{
dcRenderTarget = d2DFactory.CreateDCRenderTarget(props);
if (renderMode == RenderModes.BitmapRenderTargetOnPaint)
{
bitmapRenderTarget =
dcRenderTarget.CreateCompatibleRenderTarget(
CompatibleRenderTargetOptions.GdiCompatible,
new Microsoft.WindowsAPICodePack.DirectX.Direct2D1.SizeF(ClientSize.Width, ClientSize.Height));
}
render = null;
}
else
{
hwndRenderTarget = d2DFactory.CreateHwndRenderTarget(
props,
new HwndRenderTargetProperties(Handle, size, Microsoft.WindowsAPICodePack.DirectX.Direct2D1.PresentOptions.RetainContents));
if (renderMode == RenderModes.BitmapRenderTargetRealTime)
{
bitmapRenderTarget =
hwndRenderTarget.CreateCompatibleRenderTarget(
CompatibleRenderTargetOptions.GdiCompatible,
new Microsoft.WindowsAPICodePack.DirectX.Direct2D1.SizeF(ClientSize.Width, ClientSize.Height));
}
render = RenderSceneInBackground;
}
//move all shapes to new rendertarget and refresh
foreach (var shape in drawingShapes)
{
shape.Bitmap = Bitmap;
shape.RenderTarget = RenderTarget;
}
RefreshAll();
}
}
/// <summary>
/// Called when the browser's cursor has changed. .
/// </summary>
/// <param name="cursor">If type is Custom then customCursorInfo will be populated with the custom cursor information</param>
/// <param name="type">cursor type</param>
/// <param name="customCursorInfo">custom cursor Information</param>
void IRenderWebBrowser.OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo)
{
RenderHandler?.OnCursorChange(cursor, type, customCursorInfo);
}
/// <summary>
/// Start
/// </summary>
/// <param name="initCode">Init code</param>
/// <param name="renderCode">Render code</param>
public static void Start(
RenderHandler initCode, RenderHandler renderCode)
{
Start("UnitTest", initCode, null, renderCode);
}
protected virtual void OnImeCompositionRangeChanged(Range selectedRange, Rect[] characterBounds)
{
RenderHandler?.OnImeCompositionRangeChanged(selectedRange, characterBounds);
}
/// <summary>
/// Called when an element has been rendered to the shared texture handle.
/// This method is only called when <see cref="IWindowInfo.SharedTextureEnabled"/> is set to true
/// </summary>
/// <param name="type">indicates whether the element is the view or the popup widget.</param>
/// <param name="dirtyRect">contains the set of rectangles in pixel coordinates that need to be repainted</param>
/// <param name="sharedHandle">is the handle for a D3D11 Texture2D that can be accessed via ID3D11Device using the OpenSharedResource method.</param>
void IRenderWebBrowser.OnAcceleratedPaint(PaintElementType type, Rect dirtyRect, IntPtr sharedHandle)
{
RenderHandler?.OnAcceleratedPaint(type, dirtyRect, sharedHandle);
}
protected virtual void OnPopupSize(Rect rect)
{
RenderHandler?.OnPopupSize(rect);
}
protected virtual void OnPopupShow(bool show)
{
RenderHandler?.OnPopupShow(show);
}
protected virtual void UpdateDragCursor(DragOperationsMask operation)
{
RenderHandler?.UpdateDragCursor(operation);
}
/// <summary>
/// Create test game
/// </summary>
/// <param name="setWindowsTitle">Set windows title</param>
/// <param name="setInitCode">Set init code</param>
/// <param name="setUpdateCode">Set update code</param>
/// <param name="setRenderCode">Set render code</param>
protected TestGame(string setWindowsTitle,
RenderHandler setInitCode,
RenderHandler setUpdateCode,
RenderHandler setRenderCode)
: this(setWindowsTitle, -1, -1,
setInitCode, setUpdateCode, setRenderCode)
{
}
/// <summary>
/// Starts dragging.
/// </summary>
/// <param name="dragData">The drag data.</param>
/// <param name="mask">The mask.</param>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
bool IRenderWebBrowser.StartDragging(IDragData dragData, DragOperationsMask mask, int x, int y)
{
return(RenderHandler?.StartDragging(dragData, mask, x, y) ?? false);
}
/// <summary>
/// Start
/// </summary>
/// <param name="testName">Test name</param>
/// <param name="initCode">Init code</param>
/// <param name="renderCode">Render code</param>
public static void Start(string testName,
RenderHandler initCode, RenderHandler renderCode)
{
Start(testName, initCode, null, renderCode);
}
void IRenderWebBrowser.UpdateDragCursor(DragOperationsMask operation)
{
RenderHandler?.UpdateDragCursor(operation);
}
protected virtual void OnPaint(PaintElementType type, Rect dirtyRect, IntPtr buffer, int width, int height)
{
RenderHandler?.OnPaint(type, dirtyRect, buffer, width, height);
}
/// <summary>
/// Sets the popup is open.
/// </summary>
/// <param name="show">if set to <c>true</c> [show].</param>
void IRenderWebBrowser.OnPopupShow(bool show)
{
RenderHandler?.OnPopupShow(show);
}
/// <summary>
/// The triangle functions can check backEnd.currentSpace != surf->space
/// to see if they need to perform any new matrix setup. The modelview
/// matrix will already have been loaded, and backEnd.currentSpace will
/// be updated after the triangle function completes.
/// </summary>
/// <param name="surfaces"></param>
/// <param name="handler"></param>
private void RenderDrawSurfaceListWithFunction(DrawSurface[] surfaces, RenderHandler handler)
{
int count = surfaces.Length;
for(int i = 0; i < count; i++)
{
DrawSurface surface = surfaces[i];
// change the matrix if needed
if(surface.Space != _currentSpace)
{
_effect.View = surface.Space.ModelViewMatrix;
}
if(surface.Space.WeaponDepthHack == true)
{
idConsole.Warning("TODO: RB_EnterWeaponDepthHack();");
}
if(surface.Space.ModelDepthHack != 0.0f)
{
idConsole.Warning("TODO: RB_EnterModelDepthHack( drawSurf->space->modelDepthHack );");
}
// change the scissor if needed
if((idE.CvarSystem.GetBool("r_useScissor") == true) && (_currentScissor != surface.ScissorRectangle))
{
_currentScissor = surface.ScissorRectangle;
_graphicsDevice.ScissorRectangle = new Rectangle(
_viewDef.ViewPort.X1 + _currentScissor.X1,
_viewDef.ViewPort.Y1 + _currentScissor.Y1,
_currentScissor.X2 + 1 - _currentScissor.X1,
_currentScissor.Y2 + 1 - _currentScissor.Y1);
}
// render it
handler(surface);
if((surface.Space.WeaponDepthHack == true) || (surface.Space.ModelDepthHack != 0.0f))
{
idConsole.Warning("TODO: RB_LeaveDepthHack();");
}
_currentSpace = surface.Space;
}
}
/// <summary>
/// Called when the browser wants to move or resize the popup widget.
/// </summary>
/// <param name="rect">contains the new location and size in view coordinates. </param>
void IRenderWebBrowser.OnPopupSize(Rect rect)
{
RenderHandler?.OnPopupSize(rect);
}
/// <summary>
/// Stop rendering if removed from a parent control
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs"/> that contains the event data.</param>
protected override void OnParentChanged(EventArgs e)
{
lock (renderSyncObject)
{
if (Parent == null)
render = null;
}
base.OnParentChanged(e);
}
public override void Render(ref Matrix worldMatrix, string techniqueName,
RenderHandler renderDelegate)
{
viewProj.SetValue(State.ViewProjectionMatrix);
viewInverse.SetValue(State.ViewInverseMatrix);
if (techniqueName.Length == 0)
techniqueName = "NormalMapOnly";
base.Render(ref worldMatrix, techniqueName, renderDelegate);
}
private void SetRenderMode(RenderModes rm)
{
lock (renderSyncObject)
{
renderMode = rm;
if (!IsInitialized && !isInitializing)
return;
//clean up objects that will be invalid after RenderTarget change
if (dcRenderTarget != null)
{
dcRenderTarget.Dispose();
dcRenderTarget = null;
}
if (hwndRenderTarget != null)
{
hwndRenderTarget.Dispose();
hwndRenderTarget = null;
}
if (bitmapRenderTarget != null)
{
bitmapRenderTarget.Dispose();
bitmapRenderTarget = null;
}
peelings.Clear();
bitmap = null; //the bitmap created in dc render target can't be used in hwnd render target
// Create the screen render target
var size = new SizeU((uint)ClientSize.Width, (uint)ClientSize.Height);
var props = new RenderTargetProperties
{
PixelFormat = new PixelFormat(
Format.B8G8R8A8UNorm,
AlphaMode.Ignore),
Usage = RenderTargetUsages.GdiCompatible
};
if (renderMode == RenderModes.DCRenderTarget || renderMode == RenderModes.BitmapRenderTargetOnPaint)
{
dcRenderTarget = d2DFactory.CreateDCRenderTarget(props);
if (renderMode == RenderModes.BitmapRenderTargetOnPaint)
{
bitmapRenderTarget =
dcRenderTarget.CreateCompatibleRenderTarget(
CompatibleRenderTargetOptions.GdiCompatible,
new Microsoft.WindowsAPICodePack.DirectX.Direct2D1.SizeF(ClientSize.Width, ClientSize.Height));
}
render = null;
}
else
{
hwndRenderTarget = d2DFactory.CreateHwndRenderTarget(
props,
new HwndRenderTargetProperties(Handle, size, Microsoft.WindowsAPICodePack.DirectX.Direct2D1.PresentOptions.RetainContents));
if (renderMode == RenderModes.BitmapRenderTargetRealTime)
{
bitmapRenderTarget =
hwndRenderTarget.CreateCompatibleRenderTarget(
CompatibleRenderTargetOptions.GdiCompatible,
new Microsoft.WindowsAPICodePack.DirectX.Direct2D1.SizeF(ClientSize.Width, ClientSize.Height));
}
render = RenderSceneInBackground;
}
//move all shapes to new rendertarget and refresh
foreach (var shape in drawingShapes)
{
shape.Bitmap = Bitmap;
shape.RenderTarget = RenderTarget;
}
RefreshAll();
}
}
private void DoRendering30(RenderHandler renderDelegate, List<LightSource> lightSources)
{
string passName;
if (lightSources.Count == 0)
{
return;
}
else
{
passName = "Multiple" + GetPassName(lightSources[0].Type);
}
for (int passCount = 0; passCount < (((lightSources.Count - 1) / maxNumLightsPerPass) + 1); passCount++)
{
int count = 0;
for (int l = 0; l < maxNumLightsPerPass; l++)
{
int lightIndex = (passCount * maxNumLightsPerPass) + l;
if (lightIndex >= lightSources.Count)
{
break;
}
SetUpLightSource(lightSources[lightIndex], l);
count++;
}
numberOfLights.SetValue(count);
effect.CurrentTechnique.Passes[passName].Apply();
renderDelegate();
}
}
void IRenderWebBrowser.OnImeCompositionRangeChanged(Range selectedRange, Rect[] characterBounds)
{
RenderHandler?.OnImeCompositionRangeChanged(selectedRange, characterBounds);
}
protected virtual void OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo)
{
RenderHandler?.OnCursorChange(cursor, type, customCursorInfo);
}
public override void Render(ref Matrix worldMatrix, string techniqueName, RenderHandler renderDelegate)
{
if (renderDelegate == null)
throw new GoblinException("renderDelegate is null");
world.SetValue(worldMatrix);
viewProj.SetValue(State.ViewProjectionMatrix);
worldForNormal.SetValue(Matrix.Transpose(Matrix.Invert(worldMatrix)));
// Start shader
effect.CurrentTechnique = effect.Techniques[defaultTechnique];
{
BlendState origBlendState = State.Device.BlendState;
DepthStencilState origDepthState = State.Device.DepthStencilState;
State.Device.DepthStencilState = depthState;
State.Device.BlendState = BlendState.Opaque;
effect.CurrentTechnique.Passes["Ambient"].Apply();
renderDelegate();
State.Device.BlendState = blendState;
State.Device.DepthStencilState = depthState2;
if (is_3_0)
{
DoRendering30(renderDelegate, dirLightSources);
DoRendering30(renderDelegate, pointLightSources);
DoRendering30(renderDelegate, spotLightSources);
}
else
{
DoRendering20(renderDelegate, dirLightSources);
DoRendering20(renderDelegate, pointLightSources);
DoRendering20(renderDelegate, spotLightSources);
}
State.Device.BlendState = origBlendState;
State.Device.DepthStencilState = origDepthState;
}
}
void IRenderWebBrowser.OnVirtualKeyboardRequested(IBrowser browser, TextInputMode inputMode)
{
RenderHandler?.OnVirtualKeyboardRequested(browser, inputMode);
}
private void DoRendering20(RenderHandler renderDelegate, List<LightSource> lightSources)
{
string passName;
if (lightSources.Count == 0)
{
return;
}
else
{
passName = "Single" + GetPassName(lightSources[0].Type);
}
for (int passCount = 0; passCount < lightSources.Count; passCount++)
{
SetUpSingleLightSource(lightSources[passCount]);
effect.CurrentTechnique.Passes[passName].Apply();
renderDelegate();
}
}
/// <summary>
/// Gets the screen information (scale factor).
/// </summary>
/// <returns>ScreenInfo.</returns>
protected virtual ScreenInfo?GetScreenInfo()
{
return(RenderHandler?.GetScreenInfo());
}
public virtual void Draw(RenderHandler R_H)
{
_Update up = new _Update(this.Update);
R_H(im, rec, null, profundidad,up);
}
/// <summary>
/// Gets the view rect (width, height)
/// </summary>
/// <returns>ViewRect.</returns>
protected virtual Rect?GetViewRect()
{
return(RenderHandler?.GetViewRect());
}
/// <summary>
/// Start
/// </summary>
/// <param name="testName">Test name</param>
/// <param name="initCode">Init code</param>
/// <param name="updateCode">Update code</param>
/// <param name="renderCode">Render code</param>
public static void Start(string testName,
RenderHandler initCode,
RenderHandler updateCode,
RenderHandler renderCode)
{
using (TestGame game = new TestGame(
testName, initCode, updateCode, renderCode))
{
game.Run();
} // using (game)
}
public void Render(ref Matrix worldMatrix, string techniqueName, RenderHandler renderDelegate)
{
BasicEffect effect = (internalEffect != null) ? internalEffect : basicEffect;
effect.View = State.ViewMatrix;
effect.Projection = State.ProjectionMatrix;
effect.World = worldMatrix;
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
renderDelegate();
}
}
/// <summary>
/// Start
/// </summary>
/// <param name="testName">Test name</param>
/// <param name="windowWidth">Window width</param>
/// <param name="windowHeight">Window height</param>
/// <param name="initCode">Init code</param>
/// <param name="renderCode">Render code</param>
public static void Start(string testName,
int windowWidth, int windowHeight,
RenderHandler initCode, RenderHandler renderCode)
{
Start(testName, windowWidth, windowHeight, initCode, null, renderCode);
}
public override void Render(ref Matrix worldMatrix, string techniqueName, RenderHandler renderDelegate)
{
if (techniqueName == null)
throw new GoblinException("techniqueName is null");
if (renderDelegate == null)
throw new GoblinException("renderDelegate is null");
world.SetValue(worldMatrix);
view.SetValue(State.ViewMatrix);
projection.SetValue(State.ProjectionMatrix);
viewportScale.SetValue(new Vector2(0.5f / State.Device.Viewport.AspectRatio, -0.5f));
// Start shader
effect.CurrentTechnique = effect.Techniques[techniqueName];
// Render all passes (usually just one)
//foreach (EffectPass pass in effect.CurrentTechnique.Passes)
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
renderDelegate();
}
}
/// <summary>
/// Start
/// </summary>
/// <param name="renderCode">Render code</param>
public static void Start(RenderHandler renderCode)
{
Start(null, renderCode);
}
public override void Render(ref Matrix worldMatrix, string techniqueName,
RenderHandler renderDelegate)
{
worldInverseTranspose.SetValue(Matrix.Transpose(Matrix.Invert(worldMatrix)));
worldViewProj.SetValue(worldMatrix * State.ViewProjectionMatrix);
viewInverse.SetValue(Matrix.Invert(State.ViewMatrix));
base.Render(ref worldMatrix, "Glow", renderDelegate);
}
public virtual void Render(ref Matrix worldMatrix, String techniqueName,
RenderHandler renderDelegate)
{
if (String.IsNullOrEmpty(techniqueName))
techniqueName = "DrawWithShadowMap";
if (renderDelegate == null)
throw new GoblinException("renderDelegate is null");
State.Device.SamplerStates[1] = SamplerState.LinearWrap;
State.Device.SamplerStates[2] = SamplerState.PointClamp;
// Start shader
effect.CurrentTechnique = effect.Techniques[techniqueName];
world.SetValue(worldMatrix);
viewProj.SetValue(State.ViewProjectionMatrix);
castShadows.SetValue(lights[LightIndex].CastShadows);
isOccluder.SetValue(IsOccluder);
firstPass.SetValue(LastLayer == null);
if (LastLayer != null)
lastLayer.SetValue(LastLayer);
if (ShadowLightIndex >= 0)
{
if (this.Attribute == ShadowAttribute.ReceiveCast)
shadowsOnly.SetValue(ShadowMap.OccluderRenderTargets[ShadowLightIndex]);
else if (this.Attribute == ShadowAttribute.ReceiveOnly)
shadowsOnly.SetValue(ShadowMap.ShadowRenderTargets[ShadowLightIndex]);
}
if (!IsOccluder)
{
lightViewProj.SetValue(lights[LightIndex].LightViewProjection);
lightType.SetValue((int)lights[LightIndex].LightSource.Type);
diffuseLightColor.SetValue(lights[LightIndex].LightSource.Diffuse);
specularLightColor.SetValue(lights[LightIndex].LightSource.Specular);
ambientLightColor.SetValue(lights[LightIndex].AmbientLightColor);
if (lights[LightIndex].LightSource.Type != LightType.Directional)
{
lightPosition.SetValue(lights[LightIndex].LightSource.TransformedPosition);
atten0.SetValue(lights[LightIndex].LightSource.Attenuation0);
atten1.SetValue(lights[LightIndex].LightSource.Attenuation1);
atten2.SetValue(lights[LightIndex].LightSource.Attenuation2);
}
else
lightDirection.SetValue(-lights[LightIndex].LightSource.TransformedDirection);
if (lights[LightIndex].LightSource.Type == LightType.SpotLight)
{
lightConeAngle.SetValue(lights[LightIndex].LightSource.OuterConeAngle);
lightDecay.SetValue(lights[LightIndex].LightSource.Falloff);
lightDirection.SetValue(lights[LightIndex].LightSource.TransformedDirection);
}
}
for (int num = 0; num < effect.CurrentTechnique.Passes.Count; num++)
{
EffectPass pass = effect.CurrentTechnique.Passes[num];
pass.Apply();
renderDelegate();
}
}
public override void Draw(RenderHandler R_H)
{
_Update up = new _Update(this.Update);
R_H(im, rec, ani, profundidad, up);
}
public override void Draw(RenderHandler R_H)
{
base.Draw(R_H);
}
public void ComputeShadow(ref Matrix mat, RenderHandler renderHandler)
{
world.SetValue(mat);
for (int num = 0; num < shadowEffect.CurrentTechnique.Passes.Count; num++)
{
EffectPass pass = shadowEffect.CurrentTechnique.Passes[num];
pass.Apply();
renderHandler();
}
}
public void Render(ref Matrix worldMatrix, string techniqueName, RenderHandler renderDelegate)
{
alphaEffect.View = State.ViewMatrix;
alphaEffect.Projection = State.ProjectionMatrix;
alphaEffect.World = worldMatrix;
foreach (EffectPass pass in alphaEffect.CurrentTechnique.Passes)
{
pass.Apply();
renderDelegate();
}
}
/// <summary>
/// Dispose of resources (IDisposable implementation)
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (disposing && !disposed)
{
lock (renderSyncObject)
{
render = null;
lock (sharedSyncObject)
{
if (sharedD2DFactory != null && d2DFactory == sharedD2DFactory)
{
sharedRefCount--;
}
if (d2DFactory != null && d2DFactory != sharedD2DFactory)
{
d2DFactory.Dispose();
}
d2DFactory = null;
if (dwriteFactory != null && dwriteFactory != sharedDwriteFactory)
{
dwriteFactory.Dispose();
}
dwriteFactory = null;
if (wicFactory != null && wicFactory != sharedWicFactory)
{
wicFactory.Dispose();
}
wicFactory = null;
if (sharedRefCount == 0)
{
if (sharedD2DFactory != null)
{
sharedD2DFactory.Dispose();
}
sharedD2DFactory = null;
if (sharedDwriteFactory != null)
{
sharedDwriteFactory.Dispose();
}
sharedDwriteFactory = null;
if (sharedWicFactory != null)
{
sharedWicFactory.Dispose();
}
sharedWicFactory = null;
}
}
foreach (DrawingShape shape in drawingShapes)
{
shape.Dispose();
}
if (bitmap != null)
{
bitmap.Dispose();
}
bitmap = null;
if (dcRenderTarget != null)
{
dcRenderTarget.Dispose();
}
dcRenderTarget = null;
if (bitmapRenderTarget != null)
{
bitmapRenderTarget.Dispose();
}
bitmapRenderTarget = null;
if (hwndRenderTarget != null)
{
hwndRenderTarget.Dispose();
}
hwndRenderTarget = null;
disposed = true;
}
}
base.Dispose(disposing);
}
