protected void Blit(D3D9.Device d3d9Device, HardwarePixelBuffer rsrc, BasicBox srcBox, BasicBox dstBox, BufferResources srcBufferResources, BufferResources dstBufferResources) { if (dstBufferResources.Surface != null && srcBufferResources.Surface != null) { // Surface-to-surface var dsrcRect = ToD3DRectangle(srcBox); var ddestRect = ToD3DRectangle(dstBox); var srcDesc = srcBufferResources.Surface.Description; // If we're blitting from a RTT, try GetRenderTargetData // if we're going to try to use GetRenderTargetData, need to use system mem pool // romeoxbm: not used even in Ogre //var tryGetRenderTargetData = false; if ((srcDesc.Usage & D3D9.Usage.RenderTarget) != 0 && srcDesc.MultiSampleType == D3D9.MultisampleType.None) { // Temp texture var tmptex = new D3D9.Texture(d3d9Device, srcDesc.Width, srcDesc.Height, 1, // 1 mip level ie topmost, generate no mipmaps 0, srcDesc.Format, D3D9.Pool.SystemMemory); var tmpsurface = tmptex.GetSurfaceLevel(0); d3d9Device.GetRenderTargetData(srcBufferResources.Surface, tmpsurface); D3D9.Surface.FromSurface(dstBufferResources.Surface, tmpsurface, D3D9.Filter.Default, 0, dsrcRect, ddestRect); tmpsurface.SafeDispose(); tmptex.SafeDispose(); return; } // Otherwise, try the normal method D3D9.Surface.FromSurface(dstBufferResources.Surface, srcBufferResources.Surface, D3D9.Filter.Default, 0, dsrcRect, ddestRect); } else if (dstBufferResources.Volume != null && srcBufferResources.Volume != null) { // Volume-to-volume var dsrcBox = ToD3DBox(srcBox); var ddestBox = ToD3DBox(dstBox); D3D9.Volume.FromVolume(dstBufferResources.Volume, srcBufferResources.Volume, D3D9.Filter.Default, 0, dsrcBox, ddestBox); } else { // Software fallback base.Blit(rsrc, srcBox, dstBox); } }
/// <summary> /// /// </summary> /// <param name="c"></param> /// <param name="texId"></param> /// <param name="nx"></param> /// <param name="ny"></param> /// <param name="nz"></param> private unsafe void UpdateVolTextureData(Cell[,,] c, VolTextureId texId, int nx, int ny, int nz) { HardwarePixelBuffer buffer = _volTextures[(int)texId].GetBuffer(0, 0); buffer.Lock(HardwareBuffer.LockOptions.HBL_DISCARD); PixelBox pb = buffer.CurrentLock; uint x = 0; uint y = 0; uint z = 0; unsafe { byte *pbptr = (byte *)pb.data; for (z = pb.box.front; z < pb.box.back; z++) { for (y = pb.box.top; y < pb.box.bottom; y++) { for (x = pb.box.left; x < pb.box.right; x++) { PixelConverter.PackColour(0, 0, (uint)c[x, y, z].Dens, (uint)c[x, y, z].Light, PixelFormat.PF_BYTE_RGB, &pbptr[x]); } pbptr += pb.rowPitch; } pbptr += pb.SliceSkip; } } buffer.Unlock(); }
///<summary> /// @copydoc HardwarePixelBuffer.Blit ///</summary> public override void Blit(HardwarePixelBuffer _src, BasicBox srcBox, BasicBox dstBox) { D3DHardwarePixelBuffer src = (D3DHardwarePixelBuffer)_src; if (surface != null && src.surface != null) { // Surface-to-surface Rectangle dsrcRect = ToD3DRectangle(srcBox); Rectangle ddestRect = ToD3DRectangle(dstBox); // D3DXLoadSurfaceFromSurface SurfaceLoader.FromSurface(surface, ddestRect, src.surface, dsrcRect, Filter.None, 0); } else if (volume != null && src.volume != null) { // Volume-to-volume Box dsrcBox = ToD3DBox(srcBox); Box ddestBox = ToD3DBox(dstBox); // D3DXLoadVolumeFromVolume VolumeLoader.FromVolume(volume, ddestBox, src.volume, dsrcBox, Filter.None, 0); } else { // Software fallback base.Blit(_src, srcBox, dstBox); } }
void UpdateTexture() { lock ( renderBufferLock ) { if (renderBuffer != null && renderBufferForSize == ViewSize && renderBuffer.Length == ViewSize.X * ViewSize.Y * 4) { try { HardwarePixelBuffer pixelBuffer = texture.GetBuffer(); pixelBuffer.Lock(HardwareBuffer.LockOptions.Discard); PixelBox pixelBox = pixelBuffer.GetCurrentLock(); unsafe { fixed(byte *ptr = renderBuffer) pixelBox.WriteDataUnmanaged((IntPtr)ptr, ViewSize.X, ViewSize.Y); } pixelBuffer.Unlock(); } catch (Exception ex) { Log.Error("WebBrowserControl: Caught exception in UpdateTexture(): " + ex.Message); } } } }
/// <summary> /// Bitmaps to texture. /// </summary> /// <param name="bmp">The BMP.</param> /// <param name="texture">The texture.</param> public unsafe static void BitmapToTexture(Bitmap bitmap, Texture texture) { var bmp = bitmap.Clone(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.PixelFormat.Format32bppArgb); var bitmapData = bmp.LockBits( new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat); HardwarePixelBuffer buffer = texture.GetBuffer(); buffer.Lock(Axiom.Graphics.BufferLocking.Discard); PixelBox pixelBox = buffer.CurrentLock; UInt32 *texData = (UInt32 *)pixelBox.Data; UInt32 *mapData = (UInt32 *)bitmapData.Scan0; var height = Math.Min(pixelBox.Height, bmp.Height); var width = Math.Min(pixelBox.Width, bmp.Width); for (var y = 0; y < height; ++y) { for (var x = 0; x < width; ++x) { texData[pixelBox.RowPitch * y + x] = mapData[bitmapData.Stride / 4 * y + x]; } } buffer.Unlock(); bmp.UnlockBits(bitmapData); }
protected override void SetupContent() { SceneManager.SetSkyBox(true, "Examples/StormySkyBox", 5000); // add a skybox // setup some basic lighting for our scene SceneManager.AmbientLight = new ColorEx(0.5f, 0.5f, 0.5f); SceneManager.CreateLight("DynTexLight1").Position = new Vector3(20, 80, 50); // set initial camera position CameraManager.setStyle(CameraStyle.Manual); Camera.Position = new Vector3(0, 0, 200); TrayManager.ShowCursor(); // create our dynamic texture with 8-bit luminance texels var tex = TextureManager.Instance.CreateManual("thaw", ResourceGroupManager.DefaultResourceGroupName, TextureType.TwoD, TEXTURE_SIZE, TEXTURE_SIZE, 0, PixelFormat.L8, TextureUsage.DynamicWriteOnly); this.mTexBuf = tex.GetBuffer(); // save off the texture buffer // initialise the texture to have full luminance this.mTexBuf.Lock(BufferLocking.Discard); Memory.Set(this.mTexBuf.CurrentLock.Data, 0xff, this.mTexBuf.Size); this.mTexBuf.Unlock(); // create a penguin and attach him to our penguin node var penguin = SceneManager.CreateEntity("Penguin", "penguin.mesh"); this.mPenguinNode = SceneManager.RootSceneNode.CreateChildSceneNode(); this.mPenguinNode.AttachObject(penguin); // get and enable the penguin idle animation this.mPenguinAnimState = penguin.GetAnimationState("amuse"); this.mPenguinAnimState.IsEnabled = true; // create a snowstorm over the scene, and fast forward it a little var ps = ParticleSystemManager.Instance.CreateSystem("Snow", "Examples/Snow"); SceneManager.RootSceneNode.AttachObject(ps); ps.FastForward(30); // create a frosted screen in front of the camera, using our dynamic texture to "thaw" certain areas var ent = SceneManager.CreateEntity("Plane", PrefabEntity.Plane); ent.MaterialName = "Examples/Frost"; var node = SceneManager.RootSceneNode.CreateChildSceneNode(); node.Position = new Vector3(0, 0, 50); node.AttachObject(ent); this.mPlaneSize = ent.BoundingBox.Size.x; // remember the size of the plane this.mCursorQuery = SceneManager.CreateRayQuery(new Ray()); // create a ray scene query for the cursor this.mTimeSinceLastFreeze = 0; this.mWiping = false; }
public HardwarePixelBuffer __deref__() { global::System.IntPtr cPtr = OgrePINVOKE.HardwarePixelBufferPtr___deref__(swigCPtr); HardwarePixelBuffer ret = (cPtr == global::System.IntPtr.Zero) ? null : new HardwarePixelBuffer(cPtr, false); if (OgrePINVOKE.SWIGPendingException.Pending) { throw OgrePINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
protected void Generate() { var julia = new Julia(this.globalReal, this.globalImag, this.globalTheta); float scale = 2.5f; float vcut = 29.0f; float vscale = 1.0f / vcut; HardwarePixelBuffer buffer = this.ptex.GetBuffer(0, 0); LogManager.Instance.Write("Volume Texture Sample [info]: HardwarePixelBuffer " + buffer.Width + "x" + buffer.Height); buffer.Lock(BufferLocking.Normal); PixelBox pb = buffer.CurrentLock; LogManager.Instance.Write("Volume Texture Sample [info]: PixelBox " + pb.Width + "x" + pb.Height + "x" + pb.Depth); unsafe { var pbptr = (BufferBase)pb.Data.Clone(); for (int z = pb.Front; z < pb.Back; z++) { for (int y = pb.Top; y < pb.Bottom; y++) { pbptr += pb.Left * sizeof(uint); for (int x = pb.Left; x < pb.Right; x++) { if (z == pb.Front || z == (pb.Back - 1) || y == pb.Top || y == (pb.Bottom - 1) || x == pb.Left || x == (pb.Right - 1)) { pbptr.ToUIntPointer()[0] = 0; } else { float val = julia.Eval(((float)x / pb.Width - 0.5f) * scale, ((float)y / pb.Height - 0.5f) * scale, ((float)z / pb.Depth - 0.5f) * scale); if (val > vcut) { val = vcut; } PixelConverter.PackColor((float)x / pb.Width, (float)y / pb.Height, (float)z / pb.Depth, (1.0f - (val * vscale)) * 0.7f, PixelFormat.A8R8G8B8, pbptr); } pbptr++; } pbptr += (pb.RowPitch - pb.Right) * sizeof(uint); } pbptr += pb.SliceSkip * sizeof(uint); } buffer.Unlock(); } }
/// <summary> /// </summary> /// <param name="src"> </param> /// <param name="srcBox"> </param> /// <param name="dstBox"> </param> public override void Blit(HardwarePixelBuffer src, BasicBox srcBox, BasicBox dstBox) { var srct = (GLESTextureBuffer)src; /// TODO: Check for FBO support first /// Destination texture must be 2D /// Source texture must be 2D if ((((int)src.Usage & (int)TextureUsage.RenderTarget) != (int)TextureUsage.RenderTarget) && (srct._target == All.Texture2D)) { BlitFromTexture(srct, srcBox, dstBox); } else { base.Blit(src, srcBox, dstBox); } }
public override void Blit(HardwarePixelBuffer src, BasicBox srcBox, BasicBox dstBox) { var srct = (src as GLES2TextureBuffer); //Ogre TODO: Check for FBO support first //Destination texture must be 2D or Cube //Source texture must be 2D //Todo: src.Usage is a BufferUsage, but Ogre uses it as a TextureUsage if (false && (srct.target == All.Texture2D)) { this.BlitFromTexture(srct, srcBox, dstBox); } else { base.Blit(src, srcBox, dstBox); } }
public TerrainLayerBlendMap(Terrain parent, byte layerIdx, HardwarePixelBuffer buf) { this.mParent = parent; this.mLayerIdx = layerIdx; this.mChannel = (byte)((this.mLayerIdx - 1) % 4); this.mDirty = false; this.mBuffer = buf; this.mData = new float[this.mBuffer.Width * this.mBuffer.Height * sizeof(float)]; // we know which of RGBA we need to look at, now find it in the format // because we can't guarantee what precise format the RS gives us PixelFormat fmt = this.mBuffer.Format; var rgbaShift = PixelUtil.GetBitShifts(fmt); this.mChannelOffset = (byte)(rgbaShift[this.mChannel] / 8); // /8 convert to bytes #if AXIOM_BIG_ENDIAN // invert (dealing bytewise) mChannelOffset = (byte)(PixelUtil.GetNumElemBytes(fmt) - mChannelOffset - 1); #endif Download(); }
public override void Blit(HardwarePixelBuffer rsrc, BasicBox srcBox, BasicBox dstBox) { //Entering critical section LockDeviceAccess(); var _src = (D3D9HardwarePixelBuffer)rsrc; foreach (var it in this.mapDeviceToBufferResources) { var srcBufferResources = ((D3D9HardwarePixelBuffer)rsrc).GetBufferResources(it.Key); var dstBufferResources = it.Value; if (srcBufferResources == null) { throw new AxiomException("There are no matching resources attached to the source pixel buffer !!"); } Blit(it.Key, rsrc, srcBox, dstBox, srcBufferResources, dstBufferResources); } //Leaving critical section UnlockDeviceAccess(); }
public void Replace(byte[] bytes, string textureName) { if (this.IndexOf(textureName) < 0) { throw new ArgumentException("The texture \"" + textureName + "\"doesn't exist"); } Mogre.Image image = new Mogre.Image(); MemoryStream ms = new MemoryStream(bytes); DataStreamPtr fs2 = new DataStreamPtr(new ManagedDataStream(ms)); image.Load(fs2); PixelBox imagBox = image.GetPixelBox(); TexturePtr pTexture = this[textureName]; TextureManager lTextureManager = TextureManager.Singleton; HardwarePixelBuffer buffer = pTexture.GetBuffer(); unsafe { buffer.BlitFromMemory(imagBox); } image.Dispose(); fs2.Close(); ms.Close(); }
/// <summary> /// /// </summary> /// <param name="texture"></param> /// <param name="channel"></param> private ColorMap(Texture texture, MapChannel channel) { Debug.Assert(texture != null); mFilter = MapFilter.Bilinear; //Add self to selfList mSelfKey = texture.Name + (int)channel; mSelfList.Add(mSelfKey, this); mRefCount = 0; //Get the texture buffer HardwarePixelBuffer buff = texture.GetBuffer(); #warning Root::getSingleton().getRenderSystem()->getColourVertexElementType(); //Prepare a PixelBox (24-bit RGB) to receive the color values VertexElementType format = VertexElementType.Color_ARGB; switch (format) { case VertexElementType.Color_ARGB: //DirectX9 mPixels = new PixelBox(new BasicBox(0, 0, buff.Width, buff.Height), PixelFormat.A8B8G8R8); break; case VertexElementType.Color_ABGR: //OpenGL mPixels = new PixelBox(new BasicBox(0, 0, buff.Width, buff.Height), PixelFormat.A8B8G8R8); //Patch for Ogre's incorrect blitToMemory() when copying from PF_L8 in OpenGL if (buff.Format == PixelFormat.L8) { channel = MapChannel.Red; } break; default: throw new Exception("Unknown RenderSystem color format"); } byte[] pixelData = new byte[mPixels.ConsecutiveSize]; mPixelPtr = Memory.PinObject(pixelData); mPixels.Data = mPixelPtr; if (channel == MapChannel.Color) { //Copy to the color map directly if no channel extraction is necessary buff.BlitToMemory(mPixels); } else { unsafe { //If channel extraction is necessary, first convert to a PF_R8G8B8A8 format PixelBox //This is necessary for the code below to properly extract the desired channel PixelBox tmpPixels = new PixelBox(new BasicBox(0, 0, buff.Width, buff.Height), PixelFormat.R8G8B8A8); byte[] tmpPix = new byte[tmpPixels.ConsecutiveSize]; byte * pixPtr = (byte *)Memory.PinObject(tmpPix); tmpPixels.Data = (IntPtr)pixPtr; buff.BlitToMemory(tmpPixels); //Pick out a channel from the pixel buffer int channelOffset = 0; switch (channel) { case MapChannel.Red: channelOffset = 3; break; case MapChannel.Green: channelOffset = 2; break; case MapChannel.Blue: channelOffset = 1; break; case MapChannel.Alpha: channelOffset = 0; break; default: //should never happen throw new Exception("Invalid channel"); } //And copy that channel into the density map byte *inputPtr = (byte *)pixPtr + channelOffset; byte *outputPtr = (byte *)pixPtr + channelOffset; byte *outputEndPtr = outputPtr + mPixels.ConsecutiveSize; while (outputPtr != outputEndPtr) { *outputPtr++ = *inputPtr; *outputPtr++ = *inputPtr; *outputPtr++ = *inputPtr; *outputPtr++ = 0xFF; //Full alpha inputPtr += 4; } //Finally, delete the temporary PF_R8G8B8A8 pixel buffer Memory.UnpinObject(tmpPix); tmpPixels = null; tmpPix = null; } } }
private bool CreateRenderTarget() { DestroyRenderTarget(); if (RendererWorld.Instance == null) { return(false); } Vec2I textureSize = GetDemandTextureSize(); if (textureSize.X < 1 || textureSize.Y < 1) { return(false); } string textureName = TextureManager.Instance.GetUniqueName("WPFRenderTexture"); int hardwareFSAA = 0; if (!RendererWorld.InitializationOptions.AllowSceneMRTRendering) { if (!int.TryParse(RendererWorld.InitializationOptions.FullSceneAntialiasing, out hardwareFSAA)) { hardwareFSAA = 0; } } texture = TextureManager.Instance.Create(textureName, Texture.Type.Type2D, textureSize, 1, 0, Engine.Renderer.PixelFormat.R8G8B8, Texture.Usage.RenderTarget, false, hardwareFSAA); if (texture == null) { return(false); } currentTextureSize = textureSize; renderTexture = texture.GetBuffer().GetRenderTarget(); renderTexture.AutoUpdate = false; renderTexture.AllowAdditionalMRTs = true; camera = SceneManager.Instance.CreateCamera( SceneManager.Instance.GetUniqueCameraName("UserControl")); camera.Purpose = Camera.Purposes.MainCamera; //update camera settings camera.NearClipDistance = cameraNearFarClipDistance.Minimum; camera.FarClipDistance = cameraNearFarClipDistance.Maximum; camera.AspectRatio = (float)texture.Size.X / (float)texture.Size.Y; camera.FixedUp = cameraFixedUp; camera.Position = cameraPosition; camera.Direction = cameraDirection; camera.Fov = cameraFov; camera.ProjectionType = cameraProjectionType; camera.OrthoWindowHeight = cameraOrthoWindowHeight; viewport = renderTexture.AddViewport(camera); //Initialize HDR compositor for HDR render technique if (EngineApp.RenderTechnique == "HDR") { viewport.AddCompositor("HDR", 0); viewport.SetCompositorEnabled("HDR", true); } //Initialize Fast Approximate Antialiasing (FXAA) { bool useMRT = RendererWorld.InitializationOptions.AllowSceneMRTRendering; string fsaa = RendererWorld.InitializationOptions.FullSceneAntialiasing; if ((useMRT && (fsaa == "" || fsaa == "RecommendedSetting") && IsActivateFXAAByDefault()) || fsaa == "FXAA") { if (RenderSystem.Instance.HasShaderModel3()) { InitializeFXAACompositor(); } } } //add listener renderTargetListener = new ViewRenderTargetListener(this); renderTexture.AddListener(renderTargetListener); if (guiRenderer == null) { guiRenderer = new GuiRenderer(viewport); } else { guiRenderer.ChangeViewport(viewport); } if (controlManager == null) { controlManager = new ScreenControlManager(guiRenderer); } //initialize D3DImage output if (d3dImageIsSupported && allowUsingD3DImage) { // create a D3DImage to host the scene and monitor it for changes in front buffer availability if (d3dImage == null) { d3dImage = new D3DImage(); d3dImage.IsFrontBufferAvailableChanged += D3DImage_IsFrontBufferAvailableChanged; CompositionTarget.Rendering += D3DImage_OnRendering; } // set output to background image Background = new ImageBrush(d3dImage); // set the back buffer using the new scene pointer HardwarePixelBuffer buffer = texture.GetBuffer(0, 0); GetD3D9HardwarePixelBufferData data = new GetD3D9HardwarePixelBufferData(); data.hardwareBuffer = buffer._GetRealObject(); data.outPointer = IntPtr.Zero; unsafe { GetD3D9HardwarePixelBufferData *pData = &data; if (!RenderSystem.Instance.CallCustomMethod("Get D3D9HardwarePixelBuffer getSurface", (IntPtr)pData)) { Log.Fatal("Get D3D9HardwarePixelBuffer getSurface failed."); } } d3dImage.Lock(); d3dImage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, data.outPointer); d3dImage.Unlock(); } return(true); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(HardwarePixelBuffer obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public D3DRenderTexture(string name, HardwarePixelBuffer buffer) : base(buffer, 0) { this.name = name; }
/// <summary> /// /// </summary> /// <param name="texture"></param> /// <param name="channel"></param> private DensityMap(Texture texture, MapChannel channel) { Debug.Assert(texture != null); mFilter = MapFilter.Bilinear; //Add self to selfList mSelfKey = texture.Name + (int)channel; mSelfList.Add(mSelfKey, this); mRefCount = 0; //Get the texture buffer HardwarePixelBuffer buff = texture.GetBuffer(); //Prepare a PixelBox (8-bit greyscale) to receive the density values mPixels = new PixelBox(new BasicBox(0, 0, buff.Width, buff.Height), PixelFormat.BYTE_L); byte[] pixelData = new byte[mPixels.ConsecutiveSize]; mPixelPtr = Memory.PinObject(pixelData); mPixels.Data = mPixelPtr; if (channel == MapChannel.Color) { //Copy to the greyscale density map directly if no channel extraction is necessary buff.BlitToMemory(mPixels); } else { unsafe { //If channel extraction is necessary, first convert to a PF_R8G8B8A8 format PixelBox //This is necessary for the code below to properly extract the desired channel PixelBox tmpPixels = new PixelBox(new BasicBox(0, 0, buff.Width, buff.Height), PixelFormat.R8G8B8A8); byte[] tmpPix = new byte[tmpPixels.ConsecutiveSize]; byte * pixPtr = (byte *)Memory.PinObject(tmpPix); tmpPixels.Data = (IntPtr)pixPtr; buff.BlitToMemory(tmpPixels); //Pick out a channel from the pixel buffer int channelOffset = 0; switch (channel) { case MapChannel.Red: channelOffset = 3; break; case MapChannel.Green: channelOffset = 2; break; case MapChannel.Blue: channelOffset = 1; break; case MapChannel.Alpha: channelOffset = 0; break; default: //should never happen throw new Exception("Invalid channel"); } //And copy that channel into the density map byte *inputPtr = (byte *)pixPtr + channelOffset; byte *outputPtr = (byte *)pixPtr + channelOffset; byte *outputEndPtr = outputPtr + mPixels.ConsecutiveSize; while (outputPtr != outputEndPtr) { *outputPtr++ = *inputPtr++; inputPtr += 4; } //Finally, delete the temporary PF_R8G8B8A8 pixel buffer Memory.UnpinObject(tmpPix); tmpPixels = null; } } }
public XnaRenderTexture(string name, HardwarePixelBuffer buffer) : base(buffer, 0) { base.name = name; }