private void compileShader(FixedFuncShaders.eFixedFuncShaderIndex id, string shaderText, string[] defines, bool vertexShader)
{
Macro [] Macrodefines = null;
if (defines != null)
{
Macrodefines = new Macro[defines.Length];
for (int k = 0; k < defines.Length; k++)
{
Macrodefines[k].Definition = defines[k];
}
}
GraphicsStream gs = ShaderLoader.CompileShader(shaderText, "main", Macrodefines, null, vertexShader ? "vs_2_0" : "ps_2_0", ShaderFlags.None);
if (vertexShader)
{
BFixedFuncVS vsA = new BFixedFuncVS();
vsA.mVS = new VertexShader(BRenderDevice.getDevice(), gs);
vsA.mID = id;
mVertexShaders.Add(vsA);
}
else
{
BFixedFuncPS vsA = new BFixedFuncPS();
vsA.mPS = new PixelShader(BRenderDevice.getDevice(), gs);
vsA.mID = id;
mPixelShaders.Add(vsA);
}
gs.Close();
gs = null;
}
private void FractalForm_Resize(object sender, EventArgs e)
{
timer1.Stop();
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffect.Copy;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
device = new Device(0, DeviceType.Hardware, this, CreateFlags.HardwareVertexProcessing, presentParams);
device.RenderState.CullMode = Cull.None;
device.RenderState.Lighting = false;
device.VertexFormat = CustomVertex.PositionTextured.Format;
ShaderFlags shaderFlags = ShaderFlags.None;
Assembly assembly = Assembly.GetExecutingAssembly();
string[] d = assembly.GetManifestResourceNames();
Stream stream = assembly.GetManifestResourceStream("FractalFast0r.Resources.shaders.txt");
string errors = "";
ConstantTable consts;
GraphicsStream gs = ShaderLoader.CompileShaderFromStream(stream, "vs_main", null, null, "vs_3_0", shaderFlags, out errors, out consts);
VertexShader vs = new VertexShader(device, gs);
gs.Close();
device.VertexShader = vs;
stream.Seek(0, System.IO.SeekOrigin.Begin);
gs = ShaderLoader.CompileShaderFromStream(stream, "ps_main", null, null, "ps_3_0", shaderFlags, out errors, out consts);
PixelShader ps = new PixelShader(device, gs);
gs.Close();
stream.Close();
device.PixelShader = ps;
stop = new Stopwatch();
stop.Start();
timer1.Start();
}
void createD3DTexturesFromBlades()
{
if (mFoliageBlades.Count == 0)
{
return;
}
//create our foliage texures
int numVerts = mFoliageBlades.Count * mNumVertsPerBlade;
mD3DPositionsTexture = new Texture(BRenderDevice.getDevice(), numVerts, 1, 1, Usage.None, Format.A32B32G32R32F, Pool.Managed);
mD3DUVsTexture = new Texture(BRenderDevice.getDevice(), numVerts, 1, 1, Usage.None, Format.A32B32G32R32F, Pool.Managed);
unsafe
{
GraphicsStream gs = mD3DPositionsTexture.LockRectangle(0, 0);
Vector4 * verts = (Vector4 *)gs.InternalDataPointer;
GraphicsStream gsUV = mD3DUVsTexture.LockRectangle(0, 0);
Vector4 * UVs = (Vector4 *)gsUV.InternalDataPointer;
int vc = 0;
for (int i = 0; i < mFoliageBlades.Count; i++)
{
for (int j = 0; j < mNumVertsPerBlade; j++)
{
verts[vc].X = mFoliageBlades[i].verts[j].X;
verts[vc].Y = mFoliageBlades[i].verts[j].Y;
verts[vc].Z = mFoliageBlades[i].verts[j].Z;
verts[vc].W = 1;
//uvs
UVs[vc].X = mFoliageBlades[i].uvs[j].X;
UVs[vc].Y = mFoliageBlades[i].uvs[j].Y;
UVs[vc].Z = 0;
UVs[vc].W = 0;
vc++;
}
}
gs.Close();
mD3DPositionsTexture.UnlockRectangle(0);
gsUV.Close();
mD3DUVsTexture.UnlockRectangle(0);
}
}
/// <summary>
/// Grabs the next frame of video obtained
/// from the VMR9 and return it as an RGB image
/// </summary>
/// <returns>Returns null on failure or a Bitmap object</returns>
public Bitmap GetCurrentImage()
{
try
{
//Log.Debug("GetCurrentImage called");
lock (grabNotifier)
{
grabSucceeded = false;
grabSample = true;
if (!Monitor.Wait(grabNotifier, 500))
{
Log.Debug("FrameGrabber: Timed-out waiting for grabbed frame!");
return(null);
}
if (grabSucceeded)
{
using (GraphicsStream stream = SurfaceLoader.SaveToStream(ImageFileFormat.Bmp, rgbSurface))
{
Bitmap b = new Bitmap(Image.FromStream(stream));
// IMPORTANT: Closes and disposes the stream
// If this is not done we get a memory leak!
stream.Close();
return(b);
}
}
Log.Debug("FrameGrabber: Frame grab failed");
return(null);
}
}
catch (Exception e) // Can occur for example if the video device is lost
{
Log.Debug(e.ToString());
return(null);
}
}
public void Set3D(int left_index, int right_index)
{
Rectangle destRect = new Rectangle(0, 0, _size.Width, _size.Height);
_device.StretchRectangle(_imageLeftList[left_index], _size, _imageBuf, destRect, TextureFilter.None);
destRect.X = _size.Width;
_device.StretchRectangle(_imageRightList[right_index], _size, _imageBuf, destRect, TextureFilter.None);
GraphicsStream gStream = _imageBuf.LockRectangle(LockFlags.None);
byte[] data = new byte[] { 0x4e, 0x56, 0x33, 0x44, //NVSTEREO_IMAGE_SIGNATURE = 0x4433564e
0x00, 0x0F, 0x00, 0x00, //Screen width * 2 = 1920*2 = 3840 = 0x00000F00;
0x38, 0x04, 0x00, 0x00, //Screen height = 1080 = 0x00000438;
0x20, 0x00, 0x00, 0x00, //dwBPP = 32 = 0x00000020;
0x02, 0x00, 0x00, 0x00 }; //dwFlags = SIH_SCALE_TO_FIT = 0x00000002;
gStream.Seek(_size.Width * 2 * _size.Height * 4, System.IO.SeekOrigin.Begin); //last row
gStream.Write(data, 0, data.Length);
gStream.Close();
_imageBuf.UnlockRectangle();
}
/// <summary>
/// The device exists, but may have just been Reset(). Resources in
/// Pool.Default and any other device state that persists during
/// rendering should be set here. Render states, matrices, textures,
/// etc., that don't change during rendering can be set once here to
/// avoid redundant state setting during Render() or FrameMove().
/// </summary>
protected override void RestoreDeviceObjects(System.Object sender, System.EventArgs e)
{
// Setup render states
device.RenderState.Lighting = false;
device.RenderState.CullMode = Cull.None;
// Create index buffer
indexBuffer = new IndexBuffer(typeof(short), numberIndices, device, 0, Pool.Default);
short[] indices = (short[])indexBuffer.Lock(0, 0);
int count = 0;
for (int y = 1; y < m_Size; y++)
{
for (int x = 1; x < m_Size; x++)
{
indices[count++] = (short)((y - 1) * m_Size + (x - 1));
indices[count++] = (short)((y - 0) * m_Size + (x - 1));
indices[count++] = (short)((y - 1) * m_Size + (x - 0));
indices[count++] = (short)((y - 1) * m_Size + (x - 0));
indices[count++] = (short)((y - 0) * m_Size + (x - 1));
indices[count++] = (short)((y - 0) * m_Size + (x - 0));
}
}
indexBuffer.Unlock();
// Create vertex buffer
vertexBuffer = new VertexBuffer(typeof(Vector2), numberVertices, device, Usage.WriteOnly, 0, Pool.Default);
Vector2[] vertices = (Vector2[])vertexBuffer.Lock(0, 0);
count = 0;
for (int y = 0; y < m_Size; y++)
{
for (int x = 0; x < m_Size; x++)
{
vertices[count++] = new Vector2(((float)x / (float)(m_Size - 1) - 0.5f) * (float)Math.PI,
((float)y / (float)(m_Size - 1) - 0.5f) * (float)Math.PI);
}
}
vertexBuffer.Unlock();
// Create vertex shader
string shaderPath = null;
GraphicsStream code = null;
// Create our declaration
VertexElement[] decl = new VertexElement[] { new VertexElement(0, 0, DeclarationType.Float2, DeclarationMethod.Default, DeclarationUsage.Position, 0), VertexElement.VertexDeclarationEnd };
ourDeclaration = new VertexDeclaration(device, decl);
// Find the vertex shader file
shaderPath = DXUtil.FindMediaFile(null, "Ripple.vsh");
// Assemble the vertex shader from the file
code = ShaderLoader.FromFile(shaderPath, null, 0);
// Create the vertex shader
ourShader = new VertexShader(device, code);
code.Close();
// Set up the projection matrix
float fAspectRatio = (float)device.PresentationParameters.BackBufferWidth / (float)device.PresentationParameters.BackBufferHeight;
projectionMatrix = Matrix.PerspectiveFovRH(Geometry.DegreeToRadian(60.0f), fAspectRatio, 0.1f, 100.0f);
device.Transform.Projection = projectionMatrix;
}
public void OnTextSubtitle(ref TEXT_SUBTITLE sub)
{
try
{
if (sub.page == _activeSubPage)
{
Log.Debug("Page: " + sub.page);
Log.Debug("Character table: " + sub.encoding);
Log.Debug("Timeout: " + sub.timeOut);
Log.Debug("Timestamp: " + sub.timeStamp);
Log.Debug("Language: " + sub.language);
String content = sub.text;
if (content == null)
{
Log.Error("OnTextSubtitle: sub.txt == null!");
return;
}
Log.Debug("Content: ");
if (content.Trim().Length > 0) // debug log subtitles
{
StringTokenizer st = new StringTokenizer(content, new char[] { '\n' });
while (st.HasMore)
{
Log.Debug(st.NextToken());
}
}
else
{
Log.Debug("Page: <BLANK PAGE>");
}
}
}
catch (Exception e)
{
Log.Error("Problem with TEXT_SUBTITLE");
Log.Error(e);
}
try
{
// if we dont need the subtitle
if (!_renderSubtitles || _useBitmap || (_activeSubPage != sub.page))
{
//
//chemelli: too much logging. You can check if logs have:
// Log.Debug("Page: " + sub.page); or Log.Debug("Page: <BLANK PAGE>");
// and
// Log.Debug("Text subtitle (page {0}) ACCEPTED: [...]
// to know the evaluation of this if block
//
//Log.Debug("Text subtitle (page {0}) discarded: useBitmap is {1} and activeSubPage is {2}", sub.page, useBitmap,
// activeSubPage);
return;
}
Log.Debug("Text subtitle (page {0}) ACCEPTED: useBitmap is {1} and activeSubPage is {2}", sub.page, _useBitmap,
_activeSubPage);
Subtitle subtitle = new Subtitle();
// TODO - RenderText should directly draw to a D3D texture
subtitle.subBitmap = RenderText(sub.lc);
subtitle.timeOut = sub.timeOut;
subtitle.presentTime = sub.timeStamp / 90000.0f + _startPos;
subtitle.height = 576;
subtitle.width = 720;
subtitle.screenHeight = 576;
subtitle.screenWidth = 720;
subtitle.firstScanLine = 0;
subtitle.horizontalPosition = 0;
Texture texture = null;
try
{
// allocate new texture
texture = new Texture(GUIGraphicsContext.DX9Device, subtitle.subBitmap.Width,
subtitle.subBitmap.Height, 1, Usage.Dynamic, Format.A8R8G8B8, Pool.Default);
int pitch;
using (GraphicsStream a = texture.LockRectangle(0, LockFlags.Discard, out pitch))
{
BitmapData bd = subtitle.subBitmap.LockBits(new Rectangle(0, 0, subtitle.subBitmap.Width,
subtitle.subBitmap.Height), ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
// Quick copy of content
unsafe
{
byte *to = (byte *)a.InternalDataPointer;
byte *from = (byte *)bd.Scan0.ToPointer();
for (int y = 0; y < bd.Height; ++y)
{
for (int x = 0; x < bd.Width * 4; ++x)
{
to[pitch * y + x] = from[y * bd.Stride + x];
}
}
}
texture.UnlockRectangle(0);
subtitle.subBitmap.UnlockBits(bd);
subtitle.subBitmap.SafeDispose();
subtitle.subBitmap = null;
subtitle.texture = texture;
a.Close();
}
}
catch (Exception e)
{
Log.Debug("SubtitleRenderer: Failed to create subtitle surface!");
Log.Error(e);
return;
}
AddSubtitle(subtitle);
}
catch (Exception e)
{
Log.Error("Problem processing text subtitle");
Log.Error(e);
}
}
/// <summary>
/// Callback from subtitle filter, alerting us that a new subtitle is available
/// It receives the new subtitle as the argument sub, which data is only valid
/// for the duration of OnSubtitle.
/// </summary>
/// <returns></returns>
public int OnSubtitle(ref NATIVE_SUBTITLE sub)
{
if (!_useBitmap || !_renderSubtitles)
{
return(0);
// TODO: Might be good to let this cache and then check in Render method because bitmap subs arrive a while before display
}
Log.Debug("OnSubtitle - stream position " + _player.StreamPosition);
lock (_alert)
{
try
{
Log.Debug("SubtitleRenderer: Bitmap: bpp=" + sub.bmBitsPixel + " planes " + sub.bmPlanes + " dim = " +
sub.bmWidth + " x " + sub.bmHeight + " stride : " + sub.bmWidthBytes);
Log.Debug("SubtitleRenderer: to = " + sub.timeOut + " ts=" + sub.timeStamp + " fsl=" + sub.firstScanLine +
" h pos=" + sub.horizontalPosition + " (startPos = " + _startPos + ")");
Subtitle subtitle = new Subtitle();
subtitle.subBitmap = new Bitmap(sub.bmWidth, sub.bmHeight, PixelFormat.Format32bppArgb);
subtitle.timeOut = sub.timeOut;
subtitle.presentTime = ((double)sub.timeStamp / 1000.0f) + _startPos; // compute present time in SECONDS
subtitle.height = (uint)sub.bmHeight;
subtitle.width = (uint)sub.bmWidth;
subtitle.screenHeight = (uint)sub.screenHeight;
subtitle.screenWidth = (uint)sub.screenWidth;
subtitle.firstScanLine = sub.firstScanLine;
subtitle.horizontalPosition = sub.horizontalPosition;
subtitle.id = _subCounter++;
//Log.Debug("Received Subtitle : " + subtitle.ToString());
Texture texture = null;
try
{
// allocate new texture
texture = new Texture(GUIGraphicsContext.DX9Device, (int)subtitle.width, (int)subtitle.height, 1,
Usage.Dynamic,
Format.A8R8G8B8, GUIGraphicsContext.GetTexturePoolType());
if (texture == null)
{
Log.Debug("OnSubtitle: Failed to create new texture!");
return(0);
}
int pitch;
using (GraphicsStream a = texture.LockRectangle(0, LockFlags.Discard, out pitch))
{
// Quick copy of content
unsafe
{
byte *to = (byte *)a.InternalDataPointer;
byte *from = (byte *)sub.bmBits;
for (int y = 0; y < sub.bmHeight; ++y)
{
for (int x = 0; x < sub.bmWidth * 4; ++x)
{
to[pitch * y + x] = from[y * sub.bmWidthBytes + x];
}
}
}
a.Close();
}
texture.UnlockRectangle(0);
subtitle.texture = texture;
}
catch (Exception)
{
Log.Debug("OnSubtitle: Failed to copy bitmap data!");
return(0);
}
AddSubtitle(subtitle);
}
catch (Exception e)
{
Log.Error(e);
}
}
return(0);
}
static private unsafe void processMesh(ref BRenderGrannyMesh mesh, granny_mesh *grannyMesh)
{
BRenderPrimitive prim = new BRenderPrimitive();
//indicies
prim.mNumInds = GrannyGetMeshTriangleCount(grannyMesh) * 3;
int[] indData = new int[prim.mNumInds];
int indexSize = prim.mNumInds * sizeof(int);
IntPtr pMarshaledIndexMem = System.Runtime.InteropServices.Marshal.AllocHGlobal(indexSize);
GrannyCopyMeshIndices(grannyMesh, 4, (int *)pMarshaledIndexMem);
System.Runtime.InteropServices.Marshal.Copy(pMarshaledIndexMem, indData, 0, prim.mNumInds);
System.Runtime.InteropServices.Marshal.FreeHGlobal(pMarshaledIndexMem);
//ib's
prim.mIB = new IndexBuffer(typeof(int), prim.mNumInds, BRenderDevice.getDevice(), Usage.None, Pool.Managed);
GraphicsStream stream = prim.mIB.Lock(0, 0, LockFlags.None);
int * outInds = (int *)stream.InternalDataPointer;
for (int q = 0; q < prim.mNumInds; q++)
{
outInds[q] = indData[q];
}
prim.mIB.Unlock();
stream.Close();
//verticies
prim.mVertexSize = 0;
granny_data_type_definition *grnyVertTypeDef = GrannyGetMeshVertexType(grannyMesh);
granny_data_type_definition[] grnDTD = null;
VertexDeclaration grnVD = null;
if (!getVertexTypeFromGranny(grnyVertTypeDef, ref prim.mVertexSize, ref grnDTD, ref grnVD, ref prim.mVDecl))
{
//already logged
//CoreGlobals.getErrorManager().OnSimpleWarning(String.Format("Error loading {0} getVertexTypeFromGranny failed", filename));
return;
}
prim.mNumVerts = GrannyGetMeshVertexCount(grannyMesh);
{
int size = prim.mNumVerts * prim.mVertexSize;
IntPtr pMarshaledMem = System.Runtime.InteropServices.Marshal.AllocHGlobal(size);
byte[] tGrnVerts = new byte[size];
fixed(granny_data_type_definition *grnPD = grnDTD)
GrannyCopyMeshVertices(grannyMesh, grnPD /*grnyVertTypeDef*/, (void *)pMarshaledMem);
System.Runtime.InteropServices.Marshal.Copy(pMarshaledMem, tGrnVerts, 0, size);
System.Runtime.InteropServices.Marshal.FreeHGlobal(pMarshaledMem);
byte[] d3dVerts = new byte[size];
//swizzle the granny verts to be d3d friendly before copying them to the device
swzzlGrnyVertsToD3DVerts(tGrnVerts, grnVD, prim.mVertexSize, prim.mNumVerts,
ref d3dVerts, prim.mVDecl);
prim.mVB = new VertexBuffer(BRenderDevice.getDevice(), (int)prim.mNumVerts * prim.mVertexSize, Usage.None, VertexFormats.None, Pool.Managed);
stream = prim.mVB.Lock(0, 0, LockFlags.None);
stream.Write(d3dVerts, 0, size);
prim.mVB.Unlock();
stream.Close();
tGrnVerts = null;
grnVD.Dispose();
grnVD = null;
}
//SUB GROUPS
int groupCount = GrannyGetMeshTriangleGroupCount(grannyMesh);
granny_tri_material_group *GrannyMatGroups = GrannyGetMeshTriangleGroups(grannyMesh);
//process our material groups for this mesh
for (int k = 0; k < groupCount; k++)
{
BRenderMaterialGroup group = new BRenderMaterialGroup();
group.mStartIndex = GrannyMatGroups[k].TriFirst * 3;
group.mPrimCount = GrannyMatGroups[k].TriCount;
//load your texture here.
prim.mGroups.Add(group);
}
mesh.addRenderPrimitive(prim);
}
/// <summary>
/// Grabs the next frame of video obtained
/// from the VMR9 and return it as an RGB image
/// </summary>
/// <returns>Returns null on failure or a Bitmap object</returns>
public Bitmap GetCurrentImage()
{
try
{
//Log.Debug("GetCurrentImage called");
if (GUIGraphicsContext.VideoRenderer == GUIGraphicsContext.VideoRendererType.madVR &&
GUIGraphicsContext.Vmr9Active && !FrameGrabberD3D9Enable)
{
lock (grabNotifier)
{
if (VMR9Util.g_vmr9 != null)
{
VMR9Util.g_vmr9.MadVrGrabCurrentFrame();
try
{
if (FrameResult != null)
{
FrameResult.SafeDispose();
FrameResult = null;
}
if (GUIGraphicsContext.madVRCurrentFrameBitmap != null)
{
FrameResult = new Bitmap(GUIGraphicsContext.madVRCurrentFrameBitmap);
return(FrameResult);
}
}
catch
{
Log.Debug("FrameGrabber: Frame grab catch failed for madVR");
return(null);
// When Bitmap is not yet ready
}
}
//////// Part of code used for D3D9 setting in madVR
//////lock (grabNotifier)
//////{
////// grabSucceeded = false;
////// grabSample = true;
////// if (!Monitor.Wait(grabNotifier, 500))
////// {
////// Log.Debug("FrameGrabber: Timed-out waiting for grabbed frame!");
////// return null;
////// }
////// if (grabSucceeded)
////// {
////// try
////// {
////// if (FrameResult != null)
////// {
////// FrameResult.SafeDispose();
////// FrameResult = null;
////// }
////// if (GUIGraphicsContext.madVRFrameBitmap != null)
////// {
////// FrameResult = new Bitmap(GUIGraphicsContext.madVRFrameBitmap);
////// return FrameResult;
////// }
////// }
////// catch
////// {
////// Log.Debug("FrameGrabber: Frame grab catch failed for madVR");
////// return null;
////// // When Bitmap is not yet ready
////// }
////// }
//////}
}
// Bitmap not ready return null
Log.Debug("FrameGrabber: Frame grab failed for madVR");
return(null);
}
if (GUIGraphicsContext.VideoRenderer == GUIGraphicsContext.VideoRendererType.madVR &&
GUIGraphicsContext.Vmr9Active)
{
Surface backbuffer = null;
Bitmap b = null;
try
{
backbuffer = GUIGraphicsContext.DX9DeviceMadVr.GetBackBuffer(0, 0, BackBufferType.Mono);
using (var stream = SurfaceLoader.SaveToStream(ImageFileFormat.Bmp, backbuffer))
{
b = new Bitmap(Image.FromStream(stream));
// IMPORTANT: Closes and disposes the stream
// If this is not done we get a memory leak!
stream.Close();
stream.Dispose();
backbuffer.Dispose();
return(b);
}
}
catch (Exception)
{
backbuffer?.Dispose();
b?.Dispose();
Log.Debug("FrameGrabber: Timed-out waiting for grabbed frame!");
}
}
else
{
lock (grabNotifier)
{
grabSucceeded = false;
grabSample = true;
if (!Monitor.Wait(grabNotifier, 500))
{
Log.Debug("FrameGrabber: Timed-out waiting for grabbed frame!");
return(null);
}
if (grabSucceeded)
{
using (GraphicsStream stream = SurfaceLoader.SaveToStream(ImageFileFormat.Bmp, rgbSurface))
{
Bitmap b = new Bitmap(Image.FromStream(stream));
// IMPORTANT: Closes and disposes the stream
// If this is not done we get a memory leak!
stream.Close();
return(b);
}
}
Log.Debug("FrameGrabber: Frame grab failed");
return(null);
}
}
}
catch (Exception e) // Can occur for example if the video device is lost
{
Log.Debug(e.ToString());
return(null);
}
// Not image grabbed
return(null);
}
//-------------------------------------
public void createRenderVBs()
{
destroyRenderVBs();
int width = TerrainGlobals.getTerrain().getNumXVerts();
for (int setI = 0; setI < mSetsUsed.Count; setI++)
{
List <int> validIndexes = new List <int>();
List <int> validBladeIndexes = new List <int>();
for (int x = 0; x < BTerrainQuadNode.cMaxWidth; x++)
{
for (int z = 0; z < BTerrainQuadNode.cMaxWidth; z++)
{
int index = (x + mOwnerNodeDesc.mMinXVert) + width * (z + mOwnerNodeDesc.mMinZVert);
FoliageVertData fvd = FoliageManager.mVertData.GetValue(index);
if (fvd.compare(FoliageManager.cEmptyVertData))
{
continue;
}
if (FoliageManager.giveIndexOfSet(fvd.mFoliageSetName) == FoliageManager.giveIndexOfSet(mSetsUsed[setI]))
{
int localIndex = x + FoliageManager.cNumXBladesPerChunk * z;
validIndexes.Add(localIndex);
validBladeIndexes.Add(fvd.mFoliageSetBladeIndex);
}
}
}
if (validIndexes.Count == 0)
{
//remove this set from us
mSetsUsed.RemoveAt(setI);
setI--;
continue;
}
//now that we have our valid indexes
int numVertsPerBlade = 10;
int totalNumVerts = (validIndexes.Count * numVertsPerBlade);
//VERTEX BUFFERS
mSetVBs.Add(new VertexBuffer(typeof(VertexTypes.Pos), totalNumVerts, BRenderDevice.getDevice(), Usage.WriteOnly, VertexTypes.Pos.FVF_Flags, Pool.Default));
GraphicsStream gStream = mSetVBs[setI].Lock(0, 0, LockFlags.None);
unsafe
{
VertexTypes.Pos *verts = (VertexTypes.Pos *)gStream.InternalDataPointer;
mSetVertCount.Add(0);
//ADD OTHER STRIPS
for (int i = 0; i < validIndexes.Count; i++)
{
int vC = mSetVertCount[setI];
int startInd = validIndexes[i] * numVertsPerBlade;
//add 10 verts with: index (x*width+z), bladeIndex, 0, 0
for (int k = 0; k < numVertsPerBlade; k++)
{
verts[vC].x = startInd + k;
verts[vC].y = validBladeIndexes[i];
vC++;
}
mSetVertCount[setI] += numVertsPerBlade;
}
}
gStream.Close();
mSetVBs[setI].Unlock();
//INDEX BUFFERS (UGG WE SHOULD BE USING TRI-STRIPS!!!)
int numInds = (validIndexes.Count * ((numVertsPerBlade - 2) * 3));
mSetIBs.Add(new IndexBuffer(typeof(short), numInds, BRenderDevice.getDevice(), Usage.WriteOnly, Pool.Default));
gStream = mSetIBs[setI].Lock(0, 0, LockFlags.None);
unsafe
{
short *inds = (short *)gStream.InternalDataPointer;
mSetPolyCount.Add(0);
//add first strip
short startInd = (short)(0);
int vC = 0;
for (int i = 0; i < validIndexes.Count; i++)
{
startInd = (short)(i * (numVertsPerBlade));
short pC = (short)((numVertsPerBlade - 2) >> 1);
short sI = 0;
for (int k = 0; k < pC; k++)
{
inds[vC++] = (short)(startInd + sI + 0);
inds[vC++] = (short)(startInd + sI + 1);
inds[vC++] = (short)(startInd + sI + 2);
inds[vC++] = (short)(startInd + sI + 1);
inds[vC++] = (short)(startInd + sI + 2);
inds[vC++] = (short)(startInd + sI + 3);
sI += 2;
}
mSetPolyCount[setI] += (numVertsPerBlade - 2);
}
}
gStream.Close();
mSetIBs[setI].Unlock();
}
//COOL!
}
/// <summary>
/// Grabs the next frame of video obtained
/// from the VMR9 and return it as an RGB image
/// </summary>
/// <returns>Returns null on failure or a Bitmap object</returns>
public Bitmap GetCurrentImage()
{
lock (grabFrame)
{
try
{
//Log.Debug("GetCurrentImage called");
if (GUIGraphicsContext.VideoRenderer == GUIGraphicsContext.VideoRendererType.madVR &&
GUIGraphicsContext.Vmr9Active)
{
lock (grabNotifier)
{
if (VMR9Util.g_vmr9?._syncRoot != null)
{
lock (VMR9Util.g_vmr9?._syncRoot)
{
if (VMR9Util.g_vmr9 != null && !VMR9Util.g_vmr9._exitThread)
{
try
{
if (FrameResult != null)
{
FrameResult.SafeDispose();
FrameResult = null;
}
// Grab frame
//VMR9Util.g_vmr9.GrabCurrentFrame(); // Using C# WIP
VMR9Util.g_vmr9.MadVrGrabCurrentFrame();
if (GUIGraphicsContext.madVRCurrentFrameBitmap != null)
{
#if DEBUG
string directory = string.Format("{0}\\MediaPortal Screenshots\\{1:0000}-{2:00}-{3:00}",
Environment.GetFolderPath(Environment.SpecialFolder.MyPictures),
DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
if (!Directory.Exists(directory))
{
Log.Info("GetCurrentImage: Taking screenshot - Creating directory: {0}", directory);
Directory.CreateDirectory(directory);
}
string fileName = string.Format("{0}\\madVR - {1:00}-{2:00}-{3:00}-{4:000}", directory,
DateTime.Now.Hour,
DateTime.Now.Minute, DateTime.Now.Second, DateTime.Now.Millisecond);
#endif
FrameResult = new Bitmap(GUIGraphicsContext.madVRCurrentFrameBitmap);
#if DEBUG
// Need to be commented out for saving screenshot frame
//FrameResult.Save(fileName + ".jpg", ImageFormat.Jpeg);
#endif
return(FrameResult);
}
// Bitmap not ready return null
Log.Debug("FrameGrabber: Frame not ready for madVR");
return(null);
}
catch
{
Log.Debug("FrameGrabber: Frame grab catch failed for madVR");
return(null);
// When Bitmap is not yet ready
}
}
}
}
//////// Part of code used for D3D9 setting in madVR
//////lock (grabNotifier)
//////{
////// grabSucceeded = false;
////// grabSample = true;
////// if (!Monitor.Wait(grabNotifier, 500))
////// {
////// Log.Debug("FrameGrabber: Timed-out waiting for grabbed frame!");
////// return null;
////// }
////// if (grabSucceeded)
////// {
////// try
////// {
////// if (FrameResult != null)
////// {
////// FrameResult.SafeDispose();
////// FrameResult = null;
////// }
////// if (GUIGraphicsContext.madVRFrameBitmap != null)
////// {
////// FrameResult = new Bitmap(GUIGraphicsContext.madVRFrameBitmap);
////// return FrameResult;
////// }
////// }
////// catch
////// {
////// Log.Debug("FrameGrabber: Frame grab catch failed for madVR");
////// return null;
////// // When Bitmap is not yet ready
////// }
////// }
//////}
}
// Bitmap not ready return null
Log.Debug("FrameGrabber: Frame grab failed for madVR");
return(null);
}
//// This code is used only for D3D9 so comment it for now
//if (GUIGraphicsContext.VideoRenderer == GUIGraphicsContext.VideoRendererType.madVR &&
// GUIGraphicsContext.Vmr9Active && FrameGrabberD3D9Enable)
//{
// Surface backbuffer = null;
// Bitmap b = null;
// try
// {
// backbuffer = GUIGraphicsContext.DX9DeviceMadVr.GetBackBuffer(0, 0, BackBufferType.Mono);
// using (var stream = SurfaceLoader.SaveToStream(ImageFileFormat.Bmp, backbuffer))
// {
// b = new Bitmap(Image.FromStream(stream));
// // IMPORTANT: Closes and disposes the stream
// // If this is not done we get a memory leak!
// stream.Close();
// stream.Dispose();
// backbuffer.Dispose();
// return b;
// }
// }
// catch (Exception)
// {
// backbuffer?.Dispose();
// b?.Dispose();
// Log.Debug("FrameGrabber: Timed-out waiting for grabbed frame!");
// }
//}
else if (GUIGraphicsContext.VideoRenderer != GUIGraphicsContext.VideoRendererType.madVR) // used for EVR
{
lock (grabNotifier)
{
grabSucceeded = false;
grabSample = true;
if (!Monitor.Wait(grabNotifier, 500))
{
Log.Debug("FrameGrabber: Timed-out waiting for grabbed frame!");
return(null);
}
if (grabSucceeded)
{
using (GraphicsStream stream = SurfaceLoader.SaveToStream(ImageFileFormat.Bmp, rgbSurface))
{
Bitmap b = new Bitmap(Image.FromStream(stream));
// IMPORTANT: Closes and disposes the stream
// If this is not done we get a memory leak!
stream.Close();
return(b);
}
}
Log.Debug("FrameGrabber: Frame grab failed");
return(null);
}
}
else
{
Log.Debug("FrameGrabber: Frame grab failed");
return(null);
}
}
catch (Exception e) // Can occur for example if the video device is lost
{
Log.Debug(e.ToString());
return(null);
}
// Not image grabbed
return(null);
}
}
/// <summary>
/// Static method to calculate tangents along with the handedness of the tangents.
/// </summary>
/// <param name="model">Model to calculate the tangents on.</param>
public static void CalculateTangents(Mesh model)
{
// Get a copy of the buffers.
GraphicsStream ib = model.LockIndexBuffer(LockFlags.None);
GraphicsStream vb = model.LockVertexBuffer(LockFlags.None);
// List of the final vertex list.
List <Vertex> final = new List <Vertex>();
// Temperary lists to store vectors in.
List <Vector3> tan1 = new List <Vector3>(model.NumberVertices);
List <Vector3> tan2 = new List <Vector3>(model.NumberVertices);
// Loop through and copy the vertex list from the vertex buffer
// and to also add empty values to tan1 and tan2.
for (int i = 0; i < model.NumberVertices; i++)
{
final.Add((Vertex)vb.Read(typeof(Vertex)));
tan1.Add(new Vector3());
tan2.Add(new Vector3());
}
// Various variables used in the calculation.
int i1, i2, i3;
Vector3 v1, v2, v3;
Vector2 w1, w2, w3;
float x1, x2, y1, y2, z1, z2;
float s1, s2, t1, t2, r;
// Loop through and calculate the tangent information.
for (int i = 0; i < model.NumberFaces; i++)
{
i1 = (int)ib.Read(typeof(int));
i2 = (int)ib.Read(typeof(int));
i3 = (int)ib.Read(typeof(int));
// Get the vertex values for the 3 vertices of a face.
Vertex vertex1 = final[i1];
Vertex vertex2 = final[i2];
Vertex vertex3 = final[i3];
// Get the positions.
v1 = vertex1.Position;
v2 = vertex2.Position;
v3 = vertex3.Position;
// Get the texture coordinates.
w1 = vertex1.TexCoord;
w2 = vertex2.TexCoord;
w3 = vertex3.TexCoord;
x1 = v2.X - v1.X;
x2 = v3.X - v1.X;
y1 = v2.Y - v1.Y;
y2 = v3.Y - v1.Y;
z1 = v2.Z - v1.Z;
z2 = v3.Z - v1.Z;
s1 = w2.X - w1.X;
s2 = w3.X - w1.X;
t1 = w2.Y - w1.Y;
t2 = w3.Y - w1.Y;
r = 1.0F / (s1 * t2 - s2 * t1);
// Calculate the direction of the vector
Vector3 sdir = new Vector3((t2 * x1 - t1 * x2) * r,
(t2 * y1 - t1 * y2) * r,
(t2 * z1 - t1 * z2) * r);
// Calculate the direction of the uv
Vector3 tdir = new Vector3((s1 * x2 - s2 * x1) * r,
(s1 * y2 - s2 * y1) * r,
(s1 * z2 - s2 * z1) * r);
Vector3 temp1 = tan1[i1];
Vector3 temp2 = tan1[i2];
Vector3 temp3 = tan1[i3];
Vector3 temp4 = tan2[i1];
Vector3 temp5 = tan2[i2];
Vector3 temp6 = tan2[i3];
tan1[i1] = temp1 + sdir;
tan1[i2] = temp2 + sdir;
tan1[i3] = temp3 + sdir;
tan2[i1] = temp4 + tdir;
tan2[i2] = temp5 + tdir;
tan2[i3] = temp6 + tdir;
}
for (int i = 0; i < model.NumberVertices; i++)
{
Vertex tempVertex = final[i];
Vector3 n = tempVertex.Normal;
Vector3 t = tan1[i];
Vector3 temp = (t - n * Vector3.Dot(n, t));
temp.Normalize();
// Gram-Schmidt orthogonalize
tempVertex.Tangent = new Vector4(temp.X, temp.Y, temp.Z, 1.0f);
// Calculate the handedness
tempVertex.Tangent.W = (Vector3.Dot(Vector3.Cross(n, t), tan2[i]) < 0.0F) ? -1.0F : 1.0F;
final[i] = tempVertex;
}
ib.Close();
vb.Close();
model.SetVertexBufferData(final.ToArray(), LockFlags.None);
}
public void toTextureArray(ref List <Texture> mTempAlphaTextures, int minXVert, int minZVert)
{
bool doBlendedFill = true;
//lock in our alpha texture
int slicePitch = (int)(BTerrainTexturing.getAlphaTextureWidth() * BTerrainTexturing.getAlphaTextureHeight());
int count = Math.Min(mTempAlphaTextures.Count, mLayers.Count);
int width = (int)BTerrainTexturing.getAlphaTextureWidth();
int height = (int)BTerrainTexturing.getAlphaTextureHeight();
byte[] tempLargerImg = new byte[(width + 2) * (height + 2)];
byte[] bordered = new byte[width * height];
int i = 0;
for (i = 0; i < count; i++)
{
if (mTempAlphaTextures[i] != null)
{
GraphicsStream texstream = mTempAlphaTextures[i].LockRectangle(0, LockFlags.None);
if (i == 0)
{
for (int k = 0; k < slicePitch; k++)
{
texstream.WriteByte(255);
}
}
else
{
if (doBlendedFill)
{
fillCreateLayer(mLayers[i].mAlphaLayer, mLayers[i].mActiveTextureIndex, mLayers[i].mLayerType, minXVert, minZVert, tempLargerImg, bordered);
texstream.Write(bordered, 0, slicePitch);
}
else
{
texstream.Write(mLayers[i].mAlphaLayer, 0, slicePitch);
}
}
mTempAlphaTextures[i].UnlockRectangle(0);
texstream.Close();
}
else
{
}
}
//we've got more layers than we've preallocated
if (mTempAlphaTextures.Count < mLayers.Count)
{
int diff = mLayers.Count - mTempAlphaTextures.Count;
for (int k = 0; k < diff; k++)
{
mTempAlphaTextures.Add(new Texture(BRenderDevice.getDevice(), (int)BTerrainTexturing.getAlphaTextureWidth(), (int)BTerrainTexturing.getAlphaTextureHeight(), 1, 0, Format.L8, Pool.Managed));
GraphicsStream texstream = mTempAlphaTextures[mTempAlphaTextures.Count - 1].LockRectangle(0, LockFlags.None);
if (doBlendedFill)
{
fillCreateLayer(mLayers[i + k].mAlphaLayer, mLayers[i + k].mActiveTextureIndex, mLayers[i + k].mLayerType, minXVert, minZVert, tempLargerImg, bordered);
texstream.Write(bordered, 0, slicePitch);
}
else
{
texstream.Write(mLayers[i + k].mAlphaLayer, 0, slicePitch);
}
mTempAlphaTextures[mTempAlphaTextures.Count - 1].UnlockRectangle(0);
texstream.Close();
}
}
tempLargerImg = null;
}
