/// <summary>
/// Class level dispose method
/// </summary>
/// <remarks>
/// When implementing this method in an inherited class the following template should be used;
/// protected override void dispose( bool disposeManagedResources )
/// {
/// if ( !isDisposed )
/// {
/// if ( disposeManagedResources )
/// {
/// // Dispose managed resources.
/// }
///
/// // There are no unmanaged resources to release, but
/// // if we add them, they need to be released here.
/// }
///
/// // If it is available, make the call to the
/// // base class's Dispose(Boolean) method
/// base.dispose( disposeManagedResources );
/// }
/// </remarks>
/// <param name="disposeManagedResources">True if Unmanaged resources should be released.</param>
protected override void dispose(bool disposeManagedResources)
{
if (!IsDisposed)
{
if (disposeManagedResources)
{
// Dispose managed resources.
if (this.renderOperation != null)
{
//if (!this.renderOperation.IsDisposed)
// this.renderOperation.Dispose();
this.renderOperation = null;
}
if (this.skelAnimVertexData != null)
{
if (!this.skelAnimVertexData.IsDisposed)
{
this.skelAnimVertexData.Dispose();
}
this.skelAnimVertexData = null;
}
}
// There are no unmanaged resources to release, but
// if we add them, they need to be released here.
}
base.dispose(disposeManagedResources);
}
private void Init(int metersPerSample)
{
// set up the material
normalMaterial = WorldManager.Instance.DefaultTerrainMaterial;
material = normalMaterial;
// create the render operation
renderOp = new RenderOperation();
renderOp.operationType = OperationType.TriangleList;
renderOp.useIndices = true;
location = tile.Location;
// ask the world manager what LOD we should use
this.metersPerSample = metersPerSample;
targetMetersPerSample = metersPerSample;
// figure out the number of actual samples we need in the tile based on the size
// and level of detail
numSamples = tile.Size / metersPerSample;
// allocate the storage for the height map
heightMap = new float[numSamples * numSamples];
return;
}
/// <summary>
///
/// </summary>
/// <param name="op"></param>
public override void GetRenderOperation(RenderOperation op)
{
op.vertexData = vertexData;
op.indexData = null;
op.operationType = OperationType.TriangleList;
op.useIndices = false;
}
public void GetRenderOperation(RenderOperation op)
{
op.indexData = indexData;
op.operationType = OperationType.TriangleList;
op.useIndices = true;
op.vertexData = vertexData;
}
public static string Render(string text)
{
var operation = new RenderOperation(text);
operation.Process();
return(operation.Result);
}
/// <summary>Flushes the queued vertices to the graphics card</summary>
private void flush()
{
// The XNA classes don't like being fed zero values
if (this.usedVertexCount == 0)
{
return;
}
if (this.usedIndexCount == 0)
{
this.BatchDrawer.Select(this.vertices, this.usedVertexCount);
}
else
{
this.BatchDrawer.Select(
this.vertices, this.usedVertexCount,
this.indices, this.usedIndexCount
);
}
// Draw all queued primitives, one after another
for (int index = 1; index < this.operations.Count; ++index)
{
// Cache the render operation to keep the following code readable
RenderOperation operation = this.operations[index];
this.BatchDrawer.Draw(
operation.BaseVertexIndex,
operation.VertexCount,
operation.StartIndex,
operation.EndIndex - operation.StartIndex,
operation.PrimitiveType,
operation.DrawContext
);
} // for index
}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.DeferredNormal)
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
nrmGenVS.SetValue("mvp", ref mvp);
nrmGenPS.SetValue("move", move);
nrmGenPS.SetTexture("dudvMap", mat.GetTexture(0));
nrmGenPS.SetTexture("normalMap", mat.GetTexture(1));
}
else
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
Vector3 vpos = EffectParams.CurrentCamera.Position;
vtxShader.SetValue("mvp", ref mvp);
vtxShader.SetValue("world", ref op.Transformation);
vtxShader.SetValue("viewPos", ref vpos);
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
vtxShader.SetValue("smTrans", lightPrjTrans);
pixShader.SetTexture("dudvMap", mat.GetTexture(0));
pixShader.SetTexture("normalMap", mat.GetTexture(1));
pixShader.SetTexture("reflectionMap", reflection);
pixShader.SetValue("move", move);
}
}
public RenderOperation CreateBillboardBuffer()
{
RenderOperation renderOp = new RenderOperation();
renderOp.operationType = OperationType.TriangleFan;
renderOp.useIndices = false;
VertexData vertexData = new VertexData();
vertexData.vertexCount = 4;
vertexData.vertexStart = 0;
// free the original vertex declaration to avoid a leak
HardwareBufferManager.Instance.DestroyVertexDeclaration(vertexData.vertexDeclaration);
// use common vertex declaration
vertexData.vertexDeclaration = TreeGroup.BillboardVertexDeclaration;
// create the hardware vertex buffer and set up the buffer binding
HardwareVertexBuffer hvBuffer = HardwareBufferManager.Instance.CreateVertexBuffer(
vertexData.vertexDeclaration.GetVertexSize(0), vertexData.vertexCount,
BufferUsage.DynamicWriteOnly, false);
vertexData.vertexBufferBinding.SetBinding(0, hvBuffer);
renderOp.vertexData = vertexData;
return(renderOp);
}
public override void GetRenderOperation(RenderOperation op)
{
op.useIndexes = true;
op.operationType = RenderOperation.OperationTypes.OT_TRIANGLE_LIST;
op.vertexData = _patch.VertexData;
op.indexData = _patch.IndexData;
}
public override void GetRenderOperation(RenderOperation op)
{
op.useIndexes = true;
op.operationType = RenderOperation.OperationTypes.OT_TRIANGLE_LIST;
op.vertexData = _patch.VertexData;
op.indexData = _patch.IndexData;
}
public void GetRenderOperation(RenderOperation op)
{
op.vertexData = parent.renderOp2.vertexData;
op.useIndices = parent.renderOp2.useIndices;
op.indexData = parent.renderOp2.indexData;
op.operationType = parent.renderOp2.operationType;
}
public void getRenderOperation(RenderOperation op)
{
OgreOverlayPINVOKE.PanelOverlayElement_getRenderOperation(swigCPtr, RenderOperation.getCPtr(op));
if (OgreOverlayPINVOKE.SWIGPendingException.Pending)
{
throw OgreOverlayPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void buildFrom(SubMesh baseSubMesh, RenderOperation renderOperation)
{
OgrePINVOKE.InstanceBatch_buildFrom(swigCPtr, SubMesh.getCPtr(baseSubMesh), RenderOperation.getCPtr(renderOperation));
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Setup(Material mat, ref RenderOperation op)
{
//Matrix m = EffectParams.CurrentCamera.ViewMatrix;
//m.TranslationValue = new Vector3();
//m *= EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix);
}
public void getRenderOperation(RenderOperation op)
{
OgrePINVOKE.InstanceBatch_getRenderOperation(swigCPtr, RenderOperation.getCPtr(op));
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public void getRenderOperation(RenderOperation op)
{
OgrePINVOKE.ManualObject_ManualObjectSection_getRenderOperation__SWIG_1(swigCPtr, RenderOperation.getCPtr(op));
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public void BoundaryChange()
{
Debug.Assert(inBoundary);
DisposeBuffers();
renderOp = null;
BuildBuffers();
}
/// <summary>
///
/// </summary>
/// <param name="op"></param>
public void GetRenderOperation(RenderOperation op)
{
// use LOD
subMesh.GetRenderOperation(op, parent.MeshLodIndex);
// Deal with any vertex data overrides
// if (!hardwareSkinningEnabled)
op.vertexData = GetVertexDataForBinding();
}
public void getRenderOperation(RenderOperation arg0)
{
OgrePINVOKE.BillboardChain_getRenderOperation(swigCPtr, RenderOperation.getCPtr(arg0));
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public void getRenderOperation(RenderOperation op)
{
OgrePINVOKE.Node_DebugRenderable_getRenderOperation(swigCPtr, RenderOperation.getCPtr(op));
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void setRenderOperation(RenderOperation rend)
{
OgrePINVOKE.SimpleRenderable_setRenderOperation(swigCPtr, RenderOperation.getCPtr(rend));
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public void _getRenderOperation(RenderOperation rend)
{
OgrePINVOKE.SubMesh__getRenderOperation__SWIG_1(swigCPtr, RenderOperation.getCPtr(rend));
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
private void DestroyHardwareBuffer()
{
this.renderOp.vertexData.Dispose();
this.renderOp.Dispose();
this.renderOp = null;
this.hardwareBuffer.Dispose();
this.hardwareBuffer = null;
}
public virtual RenderOperation build(SubMesh baseSubMesh)
{
RenderOperation ret = new RenderOperation(OgrePINVOKE.InstanceBatch_build(swigCPtr, SubMesh.getCPtr(baseSubMesh)), true);
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
/// <summary>
///
/// </summary>
/// <param name="op"></param>
public void GetRenderOperation(RenderOperation op)
{
Debug.Assert(renderOp.vertexData != null, "attempting to render stitch with no vertexData");
Debug.Assert(renderOp.indexData != null, "attempting to render stitch with no indexData");
op.useIndices = this.renderOp.useIndices;
op.operationType = this.renderOp.operationType;
op.vertexData = this.renderOp.vertexData;
op.indexData = this.renderOp.indexData;
}
public override void GetRenderOperation(RenderOperation op)
{
Debug.Assert(renderOp.vertexData != null, "attempting to render heightField with no vertexData");
Debug.Assert(renderOp.indexData != null, "attempting to render heightField with no indexData");
op.useIndices = renderOp.useIndices;
op.operationType = renderOp.operationType;
op.vertexData = renderOp.vertexData;
op.indexData = renderOp.indexData;
}
public override void GetRenderOperation(RenderOperation op)
{
op.useIndices = this.renderOp.useIndices;
op.operationType = this.renderOp.operationType;
op.vertexData = this.renderOp.vertexData;
op.indexData = this.renderOp.indexData;
}
public RenderOperation getRenderOperation()
{
global::System.IntPtr cPtr = OgrePINVOKE.ManualObject_ManualObjectSection_getRenderOperation__SWIG_0(swigCPtr);
RenderOperation ret = (cPtr == global::System.IntPtr.Zero) ? null : new RenderOperation(cPtr, false);
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public RenderOperation getRenderOperationForUpdate()
{
global::System.IntPtr cPtr = OgrePINVOKE.ShadowRenderable_getRenderOperationForUpdate(swigCPtr);
RenderOperation ret = (cPtr == global::System.IntPtr.Zero) ? null : new RenderOperation(cPtr, false);
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public RenderControl() : base()
{
// TODO: придумать как перебрасывать размер и разрешение
this.Resolution = 20;
this.Width = 1000;
this.Height = 1000;
Cols = (int)(this.Width / Resolution);
Rows = (int)(this.Height / Resolution);
_Frontend = Frontend.GetInstance(cols: Cols, rows: Rows);
_RenderOperation = new RenderOperation(new Rect(0, 0, this.Width, this.Height), _Frontend, Cols, Rows, Resolution);
}
public RenderSet(RenderOperation root, int numberOfFragmentsToRender)
{
renderSet.Add(root, null);
while (renderSet.Count < numberOfFragmentsToRender) {
foreach (KeyValuePair<RenderOperation, object> kvp in renderSet) {
RenderOperation first = kvp.Key;
first.Fragment.MakeChilds();
renderSet.Remove(first);
AddOperation(first.LeftTopQuater);
AddOperation(first.RightTopQuater);
AddOperation(first.LeftBottomQuater);
AddOperation(first.RightBottomQuater);
break;
}
}
}
/// <summary>
/// Internal constructor, only allows creation of StitchRenderables within the scene manager.
/// </summary>
internal StitchRenderable(TerrainPatch terrainPatch, VertexData vertexData, IndexData indexData,
int numSamples, int southMetersPerSample, int eastMetersPerSample)
{
renderDetail = SceneDetailLevel.Solid;
parent = terrainPatch;
renderOp = new RenderOperation();
renderOp.operationType = OperationType.TriangleList;
renderOp.useIndices = true;
renderOp.vertexData = vertexData;
renderOp.indexData = indexData;
isVisible = true;
this.numSamples = numSamples;
this.southMetersPerSample = southMetersPerSample;
this.eastMetersPerSample = eastMetersPerSample;
}
public void Render()
{
DateTime startTime = HighPrecisionTimer.Now;
while(data.Size < fractal.View.BoundingBoxSize * 2) {
data.ExtendRoot();
}
Matrix rotation = new Matrix();
rotation.Rotate((float)fractal.View.CurrentAngle);
graphics.CompositingQuality = CompositingQuality.HighSpeed;
graphics.InterpolationMode = InterpolationMode.Bilinear;
graphics.SmoothingMode = SmoothingMode.HighSpeed;
graphics.ResetTransform();
graphics.MultiplyTransform(rotation, MatrixOrder.Append);
// From [-1,1] to [0,w]
graphics.TranslateTransform(1, 1, MatrixOrder.Append);
graphics.ScaleTransform(renderRectangle.Width / 2, renderRectangle.Height / 2, MatrixOrder.Append);
RectangleD renderArea = new RectangleD((-fractal.View.Xpos + -data.Size / 2) * fractal.View.Xzoom,
(-fractal.View.Ypos + -data.Size / 2) * fractal.View.Xzoom,
fractal.View.Xzoom * data.Size,
fractal.View.Xzoom * data.Size);
pixelSize = Math.Min(2d / renderRectangle.Width, 2d / renderRectangle.Height);
RenderOperation root = new RenderOperation(null, data.Root, data.Area, renderArea, rotation);
renderSet = new RenderSet(root, (int)numberOfFragmentsToRender);
Render(renderSet.RenderOperations);
numberOfFragmentsRendered = renderSet.Count;
actualRenderTime = HighPrecisionTimer.Now - startTime;
double timeFraction = (double)actualRenderTime.Ticks / (double)targetRenderTime.Ticks;
double optimalCount = (double)numberOfFragmentsToRender / timeFraction;
numberOfFragmentsToRender = numberOfFragmentsToRender * (1 - convergance) + optimalCount * convergance;
numberOfFragmentsToRender = Math.Max(16d, numberOfFragmentsToRender);
}
public override void Setup(Material mat, ref RenderOperation op)
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", ref mvp);
//vtxShader.SetValue("cameraZ", EffectParams.InvView.Forward);
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Anisotropic;
state.MagFilter = TextureFilter.Anisotropic;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
pixShader.SetValue("k_a", mat.Ambient);
pixShader.SetValue("k_d", mat.Diffuse);
pixShader.SetValue("k_e", mat.Emissive);
pixShader.SetSamplerState("texDif", ref state);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
if (clrTex == null)
{
pixShader.SetTexture("texDif", noTexture);
}
else
{
pixShader.SetTexture("texDif", clrTex);
}
}
}
public override void Setup(Material mat, ref RenderOperation op)
{
//Matrix m = EffectParams.CurrentCamera.ViewMatrix;
//m.TranslationValue = new Vector3();
//m *= EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix);
}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.DeferredNormal)
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
nrmGenVS.SetValue("mvp", ref mvp);
nrmGenPS.SetValue("move", move);
nrmGenPS.SetTexture("dudvMap", mat.GetTexture(0));
nrmGenPS.SetTexture("normalMap", mat.GetTexture(1));
}
else
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
Vector3 vpos = EffectParams.CurrentCamera.Position;
vtxShader.SetValue("mvp", ref mvp);
vtxShader.SetValue("world", ref op.Transformation);
vtxShader.SetValue("viewPos", ref vpos);
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
vtxShader.SetValue("smTrans", lightPrjTrans);
pixShader.SetTexture("dudvMap", mat.GetTexture(0));
pixShader.SetTexture("normalMap", mat.GetTexture(1));
pixShader.SetTexture("reflectionMap", reflection);
pixShader.SetValue("move", move);
}
}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.Depth)
{
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
shdVtxShader.SetValue("mvp", ref lightPrjTrans);
}
else if (mode == RenderMode.DeferredNormal)
{
Matrix worldView = op.Transformation * EffectParams.CurrentCamera.ViewMatrix;
Matrix mvp = worldView * EffectParams.CurrentCamera.ProjectionMatrix;
nrmGenVShader.SetValue("mvp", ref mvp);
nrmGenVShader.SetValue("worldView", ref worldView);
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Linear;
state.MagFilter = TextureFilter.Linear;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
nrmGenPShader.SetSamplerState("texDif", ref state);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
if (clrTex == null)
{
nrmGenPShader.SetTexture("texDif", noTexture);
}
else
{
nrmGenPShader.SetTexture("texDif", clrTex);
}
stateSetted = true;
}
}
else
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", ref mvp);
vtxShader.SetValue("world", ref op.Transformation);
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
vtxShader.SetValue("smTrans", lightPrjTrans);
WorldObject wo = op.Sender as WorldObject;
if (wo != null)
{
pixShader.SetValue("visiblity", wo.Visiblity);
}
else
{
pixShader.SetValue("visiblity", 1.0f);
}
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Anisotropic;
state.MagFilter = TextureFilter.Anisotropic;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
pixShader.SetValue("k_a", mat.Ambient);
pixShader.SetValue("k_d", mat.Diffuse);
pixShader.SetValue("k_s", mat.Specular);
pixShader.SetValue("k_e", mat.Emissive);
pixShader.SetValue("k_power", mat.Power);
pixShader.SetSamplerState("texDif", ref state);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
if (clrTex == null)
{
pixShader.SetTexture("texDif", noTexture);
}
else
{
pixShader.SetTexture("texDif", clrTex);
}
if (mat.IsVegetation)
{
vtxShader.SetValue("isVegetation", new Vector4(100, 100, 100, 100));
}
else
{
vtxShader.SetValue("isVegetation", new Vector4());
}
stateSetted = true;
}
}
}
private bool CheckSubMeshOpType(MeshPtr mesh, RenderOperation.OperationTypes opType)
{
for (ushort i = 0; i < mesh.NumSubMeshes; i++)
{
if (mesh.GetSubMesh(i).operationType != opType)
{
return false;
}
}
return true;
}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.Depth)
{
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
shdVtxShader.SetValue("mvp", ref lightPrjTrans);
}
else if (mode == RenderMode.DeferredNormal)
{
Matrix worldView = op.Transformation * EffectParams.CurrentCamera.ViewMatrix;
Matrix mvp = worldView * EffectParams.CurrentCamera.ProjectionMatrix;
nrmGenVShader.SetValue("mvp", ref mvp);
nrmGenVShader.SetValue("worldView", ref worldView);
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Linear;
state.MagFilter = TextureFilter.Linear;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
nrmGenPShader.SetSamplerState("texDif", ref state);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
if (clrTex == null)
{
nrmGenPShader.SetTexture("texDif", noTexture);
}
else
{
nrmGenPShader.SetTexture("texDif", clrTex);
}
}
}
else
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", ref mvp);
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
vtxShader.SetValue("smTrans", lightPrjTrans);
TreeBatchModel mdl = op.Sender as TreeBatchModel;
if (mdl != null)
{
vtxShader.SetValue("world", ref mdl.TreeOrientation);
}
else
{
vtxShader.SetValue("world", ref op.Transformation);
}
if (!stateSetted)
{
pixShader.SetValue("k_a", mat.Ambient);
pixShader.SetValue("k_d", mat.Diffuse);
pixShader.SetValue("k_s", mat.Specular);
pixShader.SetValue("k_e", mat.Emissive);
pixShader.SetValue("k_power", mat.Power);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
if (clrTex == null)
{
pixShader.SetTexture("texDif", null);
}
else
{
pixShader.SetTexture("texDif", clrTex);
}
pixShader.SetTexture("texFog", TerrainEffect.FogMask);
Vector2 isVeg_wind = new Vector2();
if (mat.IsVegetation)
{
isVeg_wind.X = 100;// vtxShader.SetValue("isVeg_wind", new Vector4(100, 100, 100, 100));
}
isVeg_wind.Y = winding;
vtxShader.SetValue("isVeg_wind", ref isVeg_wind);
stateSetted = true;
}
}
}
void AddOperation(RenderOperation op)
{
if (op.IsInViewFrustum) {
renderSet.Add(op, null);
}
}
public override void Setup(Material mat, ref RenderOperation op)
{
vtxShader.SetValue("mvp",
EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix);
}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.Final)
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", ref mvp);
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Anisotropic;
state.MagFilter = TextureFilter.Anisotropic;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
pixShader.SetSamplerState("texDif", ref state);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
pixShader.SetTexture("texDif", clrTex != null ? clrTex.Resource : null);
stateSetted = true;
}
}
else if (mode == RenderMode.DeferredNormal)
{
Matrix worldView = op.Transformation * EffectParams.CurrentCamera.ViewMatrix;
Matrix mvp = worldView * EffectParams.CurrentCamera.ProjectionMatrix;
nrmGenVShader.SetValue("mvp", ref mvp);
nrmGenVShader.SetValue("worldView", ref worldView);
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Linear;
state.MagFilter = TextureFilter.Linear;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
nrmGenPShader.SetSamplerState("texDif", ref state);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
if (clrTex == null)
{
nrmGenPShader.SetTexture("texDif", null);
}
else
{
nrmGenPShader.SetTexture("texDif", clrTex);
}
}
}
}
void Render(RenderOperation operation)
{
if (HighPrecisionTimer.Now - lastUserThreadActionTime > userThreadInterval) {
lastUserThreadActionTime = HighPrecisionTimer.Now;
if (UserThreadAction != null) {
UserThreadAction(this, EventArgs.Empty);
}
}
if (aborted) return;
operation.Fragment.SetColorIndexes(fractal, operation.DataSource.X, operation.DataSource.Y, operation.DataSource.Size / Fragment.FragmentSize);
RenderOperation largeEnoughRenderOperation = operation;
while (largeEnoughRenderOperation.TexelSize < pixelSize && operation.Parent != null) {
largeEnoughRenderOperation = largeEnoughRenderOperation.Parent;
bitmapCache.ReleaseCache(largeEnoughRenderOperation.Fragment);
}
BitmapCacheItem c = UpdateBitmap(largeEnoughRenderOperation.Fragment);
Draw(c.Texture, c.TextureSourceRect, largeEnoughRenderOperation.RenderDestination);
}
//public override void BeginShadowPass()
//{
// throw new NotImplementedException();
//}
//public override void EndShadowPass()
//{
// throw new NotImplementedException();
//}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.Depth)
{
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
shdVtxShader.SetValue("mvp", ref lightPrjTrans);
}
else if (mode == RenderMode.DeferredNormal)
{
nrmPixShader.SetValue("view", EffectParams.CurrentCamera.ViewMatrix);
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
nrmVtxShader.SetValue("mvp", ref mvp);
}
else
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", ref mvp);
vtxShader.SetValue("world", ref op.Transformation);
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
vtxShader.SetValue("smTrans", lightPrjTrans);
if (!stateSetted)
{
pixShader.SetValue("k_a", mat.Ambient);
pixShader.SetValue("k_d", mat.Diffuse);
stateSetted = true;
}
}
}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.Depth)
{
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
shdVtxShader.SetValue("mvp", ref lightPrjTrans);
}
else if (mode == RenderMode.DeferredNormal)
{
Matrix worldView = op.Transformation * EffectParams.CurrentCamera.ViewMatrix;
Matrix mvp = worldView * EffectParams.CurrentCamera.ProjectionMatrix;
nrmGenVShader.SetValue("mvp", ref mvp);
nrmGenVShader.SetValue("worldView", ref worldView);
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Linear;
state.MagFilter = TextureFilter.Linear;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
nrmGenPShader.SetSamplerState("texDif", ref state);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
if (clrTex != null)
{
nrmGenPShader.SetTexture("texDif", clrTex);
}
}
}
else
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", ref mvp);
vtxShader.SetValue("world", ref op.Transformation);
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
vtxShader.SetValue("smTrans", lightPrjTrans);
City sender = op.Sender as City;
pixShader.SetValue("k_a", mat.Ambient);
if (sender != null && sender.IsCaptured)
{
Color4F color = new Color4F(sender.Owner.SideColor);
pixShader.SetValue("k_d", color);
}
else
{
pixShader.SetValue("k_d", mat.Diffuse);
}
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Anisotropic;
state.MagFilter = TextureFilter.Anisotropic;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
pixShader.SetSamplerState("texDif", ref state);
ResourceHandle<Texture> clrTex = mat.GetTexture(0);
if (clrTex != null)
{
pixShader.SetTexture("texDif", clrTex);
}
stateSetted = true;
}
}
}
