public unsafe void CreateTexture(BinaryReader reader) { int w = Width; // + (4 - Width % 4) % 4; int h = Height; // + (4 - Height % 4) % 4; if (w == 0 || h == 0) { return; } if ((w < 2) || (h < 2)) { return; } GraphicsStream stream = null; ImageTexture = new Texture(DXManager.Device, w, h, 1, Usage.None, Format.A8R8G8B8, Pool.Managed); stream = ImageTexture.LockRectangle(0, LockFlags.Discard); Data = (byte *)stream.InternalDataPointer; byte[] decomp = DecompressImage(reader.ReadBytes(Length)); stream.Write(decomp, 0, decomp.Length); stream.Dispose(); ImageTexture.UnlockRectangle(0); if (HasMask) { reader.ReadBytes(12); w = Width; // + (4 - Width % 4) % 4; h = Height; // + (4 - Height % 4) % 4; MaskImageTexture = new Texture(DXManager.Device, w, h, 1, Usage.None, Format.A8R8G8B8, Pool.Managed); stream = MaskImageTexture.LockRectangle(0, LockFlags.Discard); decomp = DecompressImage(reader.ReadBytes(Length)); stream.Write(decomp, 0, decomp.Length); stream.Dispose(); MaskImageTexture.UnlockRectangle(0); } //DXManager.TextureList.Add(this); TextureValid = true; //Image.Disposing += (o, e) => //{ // TextureValid = false; // Image = null; // MaskImage = null; // Data = null; // DXManager.TextureList.Remove(this); //}; }
public unsafe void CreateTexture(BinaryReader reader) { int w = Width; // + (4 - Width % 4) % 4; int h = Height; // + (4 - Height % 4) % 4; GraphicsStream stream = null; Image = new Texture(DXManager.Device, w, h, 1, Usage.None, Format.A8R8G8B8, Pool.Managed); stream = Image.LockRectangle(0, LockFlags.Discard); Data = (byte *)stream.InternalDataPointer; byte[] decomp = DecompressImage(reader.ReadBytes(Length)); stream.Write(decomp, 0, decomp.Length); stream.Dispose(); Image.UnlockRectangle(0); if (HasMask) { reader.ReadBytes(12); w = Width; // + (4 - Width % 4) % 4; h = Height; // + (4 - Height % 4) % 4; MaskImage = new Texture(DXManager.Device, w, h, 1, Usage.None, Format.A8R8G8B8, Pool.Managed); stream = MaskImage.LockRectangle(0, LockFlags.Discard); decomp = DecompressImage(reader.ReadBytes(Length)); stream.Write(decomp, 0, decomp.Length); stream.Dispose(); MaskImage.UnlockRectangle(0); } DXManager.TextureList.Add(this); TextureValid = true; Image.Disposing += (o, e) => { TextureValid = false; Image = null; MaskImage = null; Data = null; DXManager.TextureList.Remove(this); }; CleanTime = CMain.Time + Settings.CleanDelay; }
public void render() { Device dev = this._device; //頂点データをセット dev.RenderState.CullMode = Cull.None; GraphicsStream gs = this._container.mesh.LockVertexBuffer(LockFlags.Discard); gs.Write(this._vertex_array); gs.Dispose(); this._container.mesh.UnlockVertexBuffer(); for (int i = 0; i < this._container.material.Length; i++) { if (this._container.texture[i] != null) { dev.SetTexture(0, this._container.texture[i]); } else { dev.SetTexture(0, null); } dev.Material = this._container.material[i]; this._container.mesh.DrawSubset(i); } return; }
private void использоватьGPUToolStripMenuItem_Click(object sender, EventArgs e) { if (pictureBox1.Image == null) { return; } Surface newbb = dr.CreateRenderTarget(bmhm.Width, bmhm.Height, Format.A8R8G8B8, MultiSampleType.None, 0, true); Surface oldbb = dr.GetRenderTarget(0); dr.SetRenderTarget(0, newbb); dr.BeginScene(); dr.Clear(ClearFlags.Target, Color.Black, 1f, 0); //Очистка фона eff.SetValue("w", Matrix.Scaling(2.0f, 2.0f, 2.0f)); eff.SetValue("v", Matrix.RotationX(0)); eff.SetValue("p", Matrix.RotationX(0)); eff.SetValue("txh", txh); eff.SetValue("h", himax); eff.Begin(FX.None); eff.BeginPass(2); dr.VertexFormat = CustomVertex.PositionNormalTextured.Format; dr.DrawUserPrimitives(PrimitiveType.TriangleFan, 2, dp); eff.EndPass(); eff.End(); dr.EndScene(); if (pictureBox2.Image != null) { pictureBox2.Image.Dispose(); } if (gstr != null) { gstr.Dispose(); } gstr = SurfaceLoader.SaveToStream(ImageFileFormat.Bmp, newbb); if (bmnm != null) { bmnm.Dispose(); } bmnm = (Bitmap)Image.FromStream(gstr); pictureBox2.Image = (Image)bmnm; hdv = (float)bmnm.Width / (float)bmnm.Height; if (txn != null) { txn.Dispose(); } txn = Texture.FromBitmap(dr, bmnm, Usage.None, Pool.Managed); dr.SetRenderTarget(0, oldbb); newbb.Dispose(); oldbb.Dispose(); }
public void render() { Device dev = this._device; //頂点データをセット GraphicsStream stm = this._vertex_buffer.Lock(0, 0, 0); stm.Write(this._vertex_array); stm.Dispose(); this._vertex_buffer.Unlock(); // D3dMaterial[] material = this._materials; for (int i = 0; i < material.Length; i++) { //カリング判定:何となくうまくいったから if ((0x100 & material[i].unknown) == 0x100) { dev.RenderState.CullMode = Cull.None; } else { dev.RenderState.CullMode = Cull.CounterClockwise; } dev.Material = material[i].material; if (material[i].texture != null) { dev.SetTexture(0, material[i].texture); } else { dev.SetTexture(0, null); } //インデクスをセット dev.Indices = material[i].index_buf; dev.SetStreamSource(0, this._vertex_buffer, 0); dev.VertexFormat = CustomVertex.PositionNormalTextured.Format; dev.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, material[i].ulNumIndices, 0, material[i].ulNumIndices / 3); } return; }
/// <summary> /// This callback function will be called immediately after the Direct3D device has /// been destroyed, which generally happens as a result of application termination or /// windowed/full screen toggles. Resources created in the OnCreateDevice callback /// should be released here, which generally includes all Pool.Managed resources. /// </summary> private void OnDestroyDevice(object sender, EventArgs e) { meshTextures = null; meshMaterials = null; if (systemMemoryMesh != null) { systemMemoryMesh.Dispose(); systemMemoryMesh = null; } if (adjacencyBuffer != null) { adjacencyBuffer.Dispose(); adjacencyBuffer = null; } if (defaultTexture != null) { defaultTexture.Dispose(); defaultTexture = null; } }
internal bool VisiblePixel(Point P) { bool Result = false; if (P.X < 0 || P.Y < 0 || P.X >= Size.Width || P.Y >= Size.Height) { return(false); } if (ImageTexture != null) { GraphicsStream GS = ImageTexture.LockRectangle(0, LockFlags.ReadOnly); unsafe { byte *ImageBytes = (byte *)GS.InternalData; Result = ImageBytes[(P.Y * Size.Width + P.X) * 4 + 3] != 0; } GS.Dispose(); ImageTexture.UnlockRectangle(0); } return(Result); }
public void CreateTexture(BinaryReader BReader, int[] Palette) { if (ImageTexture != null && !ImageTexture.Disposed) { ImageTexture.Dispose(); } byte[] Bytes = FullImageBytes(BReader, Palette); if (Bytes == null) { return; } LastAccess = Main.Now; ImageTexture = new Texture(DXManager.Device, Size.Width, Size.Height, 0, Usage.None, Format.A8R8G8B8, Pool.Managed); GraphicsStream GS = ImageTexture.LockRectangle(0, LockFlags.Discard); GS.Write(Bytes); GS.Dispose(); ImageTexture.UnlockRectangle(0); }
/// <summary> /// Loads a D3D shader from the assembler source. /// </summary> protected override void LoadFromSource() { string errors; // load the shader from the source string GraphicsStream microcode = ShaderLoader.FromString(source, null, ShaderFlags.SkipValidation, out errors); if (errors != null && errors != string.Empty) { string msg = string.Format("Error while compiling pixel shader '{0}':\n {1}", name, errors); throw new AxiomException(msg); } // load the code into a shader object (polymorphic) LoadFromMicrocode(microcode); if (microcode != null) { microcode.Dispose(); microcode = null; } }
/// <summary> /// Sets the data for the current vertex buffers. /// </summary> /// <param name="data"></param> /// <param name="device"></param> public void setData(List <oSingleData> data, ref Device device) { if (data == null || device == null) { return; } // Clear the link vertex arrays vertexBufferLinks = null; vertexLinks = null; // Clear the status of the previous executed functions foreach (int index in executedVertexIndices) { // Clear this vertex colouring vertexFunctions[index].Color = Color.FromArgb(60, 60, 60).ToArgb(); } executedVertexIndices.Clear(); // Clear the vertex function call links vertexLinks = new CustomVertex.TransformedColored[data.Count * 2]; vertexLinksCount = 0; if (data.Count > 0) { // Convert the data //Int32[] callArray = (Int32[]) oMemoryFunctions.RawDataToObject(ref data, typeof (Int32[])); //uint[] callArray = oMemoryFunctions.ByteArrayToUintArray(ref data); // Process the new function calls) for (int i = 0; i < data.Count; i++) { // Process this function call // Load the source function address uint sourceFunctionAddress; if (directCallSourcesHash.Contains((uint)data[i].source)) { // We can perform a hash table lookup. This was probably a direct fixed offset call. sourceFunctionAddress = (uint)directCallSourcesHash[(uint)data[i].source]; } else { // We have to do a binary search lookup, this is more expensive computationally. This was probably a PE table call. int n = functionLocationsList.BinarySearch((uint)data[i].source); if (n < 0) { n = ~n - 1; } if (n < 0) { n = 0; } sourceFunctionAddress = (uint)functionLocationsList[n]; } // Load the source vertex index, or create a new vertex if needed int sourceVertexIndex; if (functionLocationsHash.Contains(sourceFunctionAddress)) { sourceVertexIndex = (int)functionLocationsHash[sourceFunctionAddress]; } else { // We need to create the vertex for this funciton sourceVertexIndex = moduleManager.addNewFunction(sourceFunctionAddress); } if (sourceVertexIndex >= 0) { // Highlight the source index function vertexFunctions[sourceVertexIndex].Color = Color.FromArgb(255, 255, 50).ToArgb(); executedVertexIndices.Add(sourceVertexIndex); } // Load the destination vertex index, or create a new vertex if needed int destinationVertexIndex; if (functionLocationsHash.Contains((uint)((oSingleData)data[i]).destination)) { destinationVertexIndex = (int)functionLocationsHash[(uint)data[i].destination]; } else { // We need to create the vertex for this funciton destinationVertexIndex = moduleManager.addNewFunction((uint)data[i].destination); } if (destinationVertexIndex >= 0) { // Highlight the destination index function vertexFunctions[destinationVertexIndex].Color = Color.FromArgb(255, 255, 50).ToArgb(); executedVertexIndices.Add(destinationVertexIndex); } // Draw the link line if (destinationVertexIndex >= 0 && sourceVertexIndex >= 0) { vertexLinks[vertexLinksCount] = new CustomVertex.TransformedColored(vertexFunctions[sourceVertexIndex].X, vertexFunctions[sourceVertexIndex].Y + 1, vertexFunctions[sourceVertexIndex].Z, vertexFunctions[sourceVertexIndex].Rhw, Color.FromArgb(150, 0, 0).ToArgb()); vertexLinks[vertexLinksCount + 1] = new CustomVertex.TransformedColored(vertexFunctions[destinationVertexIndex].X, vertexFunctions[destinationVertexIndex].Y + 1, vertexFunctions[destinationVertexIndex].Z, vertexFunctions[destinationVertexIndex].Rhw, Color.FromArgb(0, 0, 150).ToArgb()); vertexLinksCount += 2; } } } else { vertexLinksCount = 0; } // Write the function vertex buffers if (vertexFunctionsCount > 0) { CustomVertex.TransformedColored[] vertexFunctionsRange = new CustomVertex.TransformedColored[vertexFunctionsCount]; Array.Copy(vertexFunctions, vertexFunctionsRange, vertexFunctionsRange.Length); if (vertexBufferFunctions != null) { vertexBufferFunctions.Dispose(); } vertexBufferFunctions = new VertexBuffer(typeof(CustomVertex.TransformedColored), vertexFunctionsCount, device, 0, CustomVertex.TransformedColored.Format, Pool.Default); GraphicsStream stm = vertexBufferFunctions.Lock(0, 0, 0); stm.Seek(0, SeekOrigin.Begin); stm.Write(vertexFunctionsRange); vertexBufferFunctions.Unlock(); stm.Dispose(); } // Write the link line vertex buffers if (vertexLinksCount > 0) { CustomVertex.TransformedColored[] vertexLinksRange = new CustomVertex.TransformedColored[vertexLinksCount]; Array.Copy(vertexLinks, vertexLinksRange, vertexLinksRange.Length); if (vertexBufferLinks != null) { vertexBufferLinks.Dispose(); } vertexBufferLinks = new VertexBuffer(typeof(CustomVertex.TransformedColored), vertexLinksCount, device, 0, CustomVertex.TransformedColored.Format, Pool.Default); GraphicsStream stm = vertexBufferLinks.Lock(0, 0, 0); stm.Seek(0, SeekOrigin.Begin); stm.Write(vertexLinksRange); vertexBufferLinks.Unlock(); stm.Dispose(); } else { vertexBufferLinks = null; } }
private void ExportThread() { //create timer so we can check how long it takes to create the whole file Stopwatch stopwatch = new Stopwatch(); // Begin timing stopwatch.Start(); //for (int i = 0; i < _refLibrary.Count; i++) for (int i = Convert.ToInt16(text_test_framemin.Text); i < Convert.ToInt16(text_test_framemax.Text); i++) { showRefImage = false; //turns off the ref image while we render the new library nud_frame.Value = i; //just setting this value and then calling Render() is enough to cycle through the frames backgroundColour = Color.Black; //set the background to black so the crop code can detect the blank areas and remove pure black pixels from the image, if set to any other colour the image will have a solid colour background and not become transparent UpdateTextBoxes(); //this will set the _selectedRefImage for the current frame Render(); #region Save Snapshot of the Directx panel try { Surface backbuffer = device.GetBackBuffer(0, 0, BackBufferType.Mono); //SurfaceLoader.Save("Screenshot.bmp", ImageFileFormat.Bmp, backbuffer); //saves file (to test it is working) //if you continue to Render the DirectX panel while updating the GraphicsStream it causes the device to be lost and crashes //so I just call Render(); when I need to update the panel instead of using the infinite loop thread #region Graphics Lock GraphicsStream gs = backbuffer.LockRectangle(LockFlags.Discard); gs.Position = 0; //set start position int bytesPerPixel = 4; int currentPosition = 0; int heightInPixels = 250; int widthInPixels = 250; //Crop offsets int XMin = 249; int XMax = 0; int YMin = 249; int YMax = 0; for (int y = 0; y < heightInPixels; y++) { //couldn't use the Parallel.For loop as it would overwrite the GraphicsStream.Position because it was working on two or //more pixels at once causing a speckled effect as it misses pixels (well I think that is what was causing the errors I was having) //Parallel.For(0, heightInPixels, y => //{ //int currentLine = (y * ((widthInPixels * bytesPerPixel) + (4 *12))); //4*12 is how many pixels (12 for 500pixel image) was missing from each row (not sure why 12 but I guess the backbuffer extends beyond the screen) int currentLine = (y * (widthInPixels * bytesPerPixel) + (y * (4 * 6))); //4*6 is how many pixels (6 for 250pixel image) was missing from each row (not sure why 6 but I guess the backbuffer extends beyond the screen) for (int x = 0; x < widthInPixels; x++) { byte[] bu = new byte[4]; //new byte to store current pixel data currentPosition = currentLine + (x * bytesPerPixel); //calculate current position gs.Position = currentPosition; //set pixel position in GraphicsStream gs.Read(bu, 0, 4); //read image pixel data //gets RGB values int r = bu[2]; int g = bu[1]; int b = bu[0]; Color c = Color.FromArgb(r, g, b); if (c.R != backgroundColour.R && c.G != backgroundColour.G && c.B != backgroundColour.B) //if not the same as backgroundColour set the min/max values { if (XMin > x) { XMin = x; } if (XMax < x) { XMax = x; } if (YMin > y) { YMin = y; } if (YMax < y) { YMax = y; } } //if (y == YMin) //this is a way to show where the image is cropped //{ // bu[2] = 255; // bu[1] = 0; // bu[0] = 0; //} gs.Position = currentPosition; //sets the position back to the starting pixel gs.Write(bu, 0, 4); //updates the GraphicsStream with the new changes } //}); //end of Parallel.For loop } //Shows the detected bounds of the image for testing //MessageBox.Show("XMin: " + XMin // + Environment.NewLine + "XMax: " + XMax // + Environment.NewLine + "YMin: " + YMin // + Environment.NewLine + "YMax: " + YMax // + Environment.NewLine + "Width: " + (XMax - XMin) // + Environment.NewLine + "Height: " + (YMax - YMin)); backbuffer.UnlockRectangle(); gs.Dispose(); #endregion Bitmap Preview = new Bitmap(SurfaceLoader.SaveToStream(ImageFileFormat.Bmp, backbuffer)); #region crop //create target image and draw cropped part of the Preview image to the target image Bitmap target = new Bitmap((XMax - XMin) + 1, (YMax - YMin) + 1, PixelFormat.Format32bppArgb); using (Graphics g = Graphics.FromImage(target)) { g.DrawImage(Preview, new RectangleF(0, 0, target.Width, target.Height), new RectangleF(XMin, YMin, (XMax - XMin) + 1, (YMax - YMin) + 1), GraphicsUnit.Pixel); } #endregion //Add Image and offsets to the _library _library.AddImage(target, (short)(XMin - characterGlobalOffsetX), (short)(YMin - characterGlobalOffsetY)); //target.Save("Test1.PNG", ImageFormat.Png); //testing screen capture and crop image from directx works by saving to file target.Dispose(); Preview.Dispose(); backbuffer.Dispose(); } catch (Direct3DXException ee) //Display error Messages with the DirectX code { MessageBox.Show("Message: " + ee.Message + Environment.NewLine + "ErrorString: " + ee.ErrorString + Environment.NewLine + "ErrorCode: " + ee.ErrorCode + Environment.NewLine + "StackTrace: " + ee.StackTrace ); } #endregion toolStripProgressBar.Value = i + 1; } //save file as normal .lib (true = reference file, false = normal .lib) _library.Save(false); stopwatch.Stop(); MessageBox.Show(string.Format("Time Taken: {0:n0} Seconds", stopwatch.Elapsed.TotalMilliseconds / 1000)); toolStripProgressBar.Value = 0; showRefImage = true; nud_frame.Value = 0; Render(); }
protected void BlitFromMemoryImpl(PixelBox src, BasicBox dstBox) { // TODO: This currently does way too many copies. We copy // from src to a converted buffer (if needed), then from // converted to a byte array, then into the temporary surface, // and finally from the temporary surface to the real surface. PixelBox converted = src; IntPtr bufPtr = IntPtr.Zero; GCHandle bufGCHandle = new GCHandle(); // convert to pixelbuffer's native format if necessary if (D3DHelper.ConvertEnum(src.Format) == D3D.Format.Unknown) { int bufSize = PixelUtil.GetMemorySize(src.Width, src.Height, src.Depth, format); byte[] newBuffer = new byte[bufSize]; bufGCHandle = GCHandle.Alloc(newBuffer, GCHandleType.Pinned); bufPtr = bufGCHandle.AddrOfPinnedObject(); converted = new PixelBox(src.Width, src.Height, src.Depth, format, bufPtr); PixelUtil.BulkPixelConversion(src, converted); } // int formatBytes = PixelUtil.GetNumElemBytes(converted.Format); Surface tmpSurface = device.CreateOffscreenPlainSurface(converted.Width, converted.Height, D3DHelper.ConvertEnum(converted.Format), Pool.Scratch); int pitch; // Ideally I would be using the Array mechanism here, but that doesn't seem to work GraphicsStream buf = tmpSurface.LockRectangle(LockFlags.NoSystemLock, out pitch); buf.Position = 0; unsafe { int bufSize = PixelUtil.GetMemorySize(converted.Width, converted.Height, converted.Depth, converted.Format); byte * srcPtr = (byte *)converted.Data.ToPointer(); byte[] ugh = new byte[bufSize]; for (int i = 0; i < bufSize; ++i) { ugh[i] = srcPtr[i]; } buf.Write(ugh); } tmpSurface.UnlockRectangle(); buf.Dispose(); //ImageInformation imageInfo = new ImageInformation(); //imageInfo.Format = D3DHelper.ConvertEnum(converted.Format); //imageInfo.Width = converted.Width; //imageInfo.Height = converted.Height; //imageInfo.Depth = converted.Depth; if (surface != null) { // I'm trying to write to surface using the data in converted Rectangle srcRect = ToD3DRectangleExtent(converted); Rectangle destRect = ToD3DRectangle(dstBox); SurfaceLoader.FromSurface(surface, destRect, tmpSurface, srcRect, Filter.None, 0); } else { D3D.Box srcBox = ToD3DBoxExtent(converted); D3D.Box destBox = ToD3DBox(dstBox); Debug.Assert(false, "Volume textures not yet supported"); // VolumeLoader.FromStream(volume, destBox, converted.Data, converted.RowPitch * converted.SlicePitch * formatBytes, srcBox, Filter.None, 0); VolumeLoader.FromStream(volume, destBox, buf, srcBox, Filter.None, 0); } tmpSurface.Dispose(); // If we allocated a buffer for the temporary conversion, free it here // If I used bufPtr to store my temporary data while I converted // it, I need to free it here. This invalidates converted. // My data has already been copied to tmpSurface and then to the // real surface. if (bufGCHandle.IsAllocated) { bufGCHandle.Free(); } if (doMipmapGen) { GenMipmaps(); } }