public RenderTexture(HardwarePixelBuffer buffer, int zOffset)
{
pixelBuffer = buffer;
this.zOffset = zOffset;
priority = RenderTargetPriority.High;
width = buffer.Width;
height = buffer.Height;
colorDepth = PixelUtil.GetNumElemBits(buffer.Format);
}
public RenderTexture(HardwarePixelBuffer buffer, int zOffset)
{
pixelBuffer = buffer;
this.zOffset = zOffset;
priority = RenderTargetPriority.High;
width = buffer.Width;
height = buffer.Height;
colorDepth = PixelUtil.GetNumElemBits(buffer.Format);
}
public RenderTexture( string name, HardwarePixelBuffer buffer, int zOffset )
: base( name )
{
pixelBuffer = buffer;
this.zOffset = zOffset;
Priority = RenderTargetPriority.RenderToTexture;
width = buffer.Width;
height = buffer.Height;
colorDepth = PixelUtil.GetNumElemBits( buffer.Format );
}
public virtual void Blit(HardwarePixelBuffer src, BasicBox srcBox, BasicBox dstBox)
{
if (IsLocked || src.IsLocked)
{
throw new AxiomException("Source and destination buffer may not be locked!");
}
if (src == this)
{
throw new AxiomException("Source must not be the same object.");
}
var srclock = src.Lock(srcBox, BufferLocking.ReadOnly);
var method = BufferLocking.Normal;
if (dstBox.Left == 0 && dstBox.Top == 0 && dstBox.Front == 0 && dstBox.Right == this.width &&
dstBox.Bottom == this.height &&
dstBox.Back == this.depth)
{
// Entire buffer -- we can discard the previous contents
method = BufferLocking.Discard;
}
var dstlock = Lock(dstBox, method);
if (dstlock.Width != srclock.Width || dstlock.Height != srclock.Height || dstlock.Depth != srclock.Depth)
{
// Scaling desired
Image.Scale(srclock, dstlock);
}
else
{
// No scaling needed
PixelConverter.BulkPixelConversion(srclock, dstlock);
}
Unlock();
src.Unlock();
}
public override void CreateScene()
{
// Create dynamic texture
ptex = TextureManager.Instance.CreateManual( "DynaTex", ResourceGroupManager.DefaultResourceGroupName, TextureType.TwoD, reactorExtent - 2, reactorExtent - 2, 0, PixelFormat.A8R8G8B8, TextureUsage.DynamicWriteOnly );
buffer = ptex.GetBuffer( 0, 0 );
// Set ambient light
scene.AmbientLight = new ColorEx( 0.6F, 0.6F, 0.6F );
scene.SetSkyBox( true, "SkyBox/Space", 50 );
//mRoot->getRenderSystem()->clearFrameBuffer(FBT_COLOUR, ColourValue(255,255,255,0));
// Create a light
Light l = scene.CreateLight( "MainLight" );
l.Diffuse = new ColorEx( 0.75F, 0.75F, 0.80F );
l.Specular = new ColorEx( 0.9F, 0.9F, 1F );
l.Position = new Vector3( -100, 80, 50 );
scene.RootSceneNode.AttachObject( l );
Entity planeEnt = scene.CreateEntity( "TexPlane1", PrefabEntity.Plane );
// Give the plane a texture
planeEnt.MaterialName = "Examples/DynaTest";
SceneNode node = scene.RootSceneNode.CreateChildSceneNode( new Vector3( -100, -40, -100 ) );
node.AttachObject( planeEnt );
node.Scale = new Vector3( 3.0f, 3.0f, 3.0f );
// Create objects
SceneNode blaNode = scene.RootSceneNode.CreateChildSceneNode( new Vector3( -200, 0, 50 ) );
Entity ent2 = scene.CreateEntity( "knot", "knot.mesh" );
ent2.MaterialName = "Examples/DynaTest4";
blaNode.AttachObject( ent2 );
blaNode = scene.RootSceneNode.CreateChildSceneNode( new Vector3( 200, -90, 50 ) );
ent2 = scene.CreateEntity( "knot2", "knot.mesh" );
ent2.MaterialName = "Examples/DynaTest2";
blaNode.AttachObject( ent2 );
blaNode = scene.RootSceneNode.CreateChildSceneNode( new Vector3( -110, 200, 50 ) );
// Cloaked fish
ent2 = scene.CreateEntity( "knot3", "fish.mesh" );
ent2.MaterialName = "Examples/DynaTest3";
swim = ent2.GetAnimationState( "swim" );
swim.IsEnabled = true;
blaNode.AttachObject( ent2 );
blaNode.Scale = new Vector3( 50.0f, 50.0f, 50.0f );
LogManager.Instance.Write( "HardwarePixelBuffer {0} {1} {2} ", buffer.Width, buffer.Height, buffer.Depth );
buffer.Lock( BufferLocking.Normal );
PixelBox pb = buffer.CurrentLock;
LogManager.Instance.Write( "PixelBox {0} {1} {2} {3} {4} {5} {6}", pb.Width, pb.Height, pb.Depth, pb.RowPitch, pb.SlicePitch, pb.Data, pb.Format );
buffer.Unlock();
// show GUI
overlay = OverlayManager.Instance.GetByName( "Example/DynTexOverlay" );
overlay.Show();
}
public void Blit( HardwarePixelBuffer src )
{
Blit( src, new BasicBox( 0, 0, 0, src.Width, src.Height, src.Depth ),
new BasicBox( 0, 0, 0, this.width, this.height, this.depth ) );
}
public virtual void Blit( HardwarePixelBuffer src, BasicBox srcBox, BasicBox dstBox )
{
if ( IsLocked || src.IsLocked )
{
throw new AxiomException( "Source and destination buffer may not be locked!" );
}
if ( src == this )
{
throw new AxiomException( "Source must not be the same object." );
}
var srclock = src.Lock( srcBox, BufferLocking.ReadOnly );
var method = BufferLocking.Normal;
if ( dstBox.Left == 0 && dstBox.Top == 0 && dstBox.Front == 0 && dstBox.Right == this.width &&
dstBox.Bottom == this.height &&
dstBox.Back == this.depth )
{
// Entire buffer -- we can discard the previous contents
method = BufferLocking.Discard;
}
var dstlock = Lock( dstBox, method );
if ( dstlock.Width != srclock.Width || dstlock.Height != srclock.Height || dstlock.Depth != srclock.Depth )
{
// Scaling desired
Image.Scale( srclock, dstlock );
}
else
{
// No scaling needed
PixelConverter.BulkPixelConversion( srclock, dstlock );
}
Unlock();
src.Unlock();
}
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 XnaRenderTexture( string name, HardwarePixelBuffer buffer )
: base( buffer, 0 )
{
base.name = name;
}
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 );
if ( d3d9Device.GetRenderTargetData( srcBufferResources.Surface, tmpsurface ).Success )
{
// Hey, it worked
// Copy from this surface instead
var res = D3D9.Surface.FromSurface( dstBufferResources.Surface, tmpsurface, D3D9.Filter.Default, 0, dsrcRect,
ddestRect );
if ( res.Failure )
{
tmpsurface.SafeDispose();
tmptex.SafeDispose();
throw new AxiomException( "D3D9.Surface.FromSurface failed in D3D9HardwarePixelBuffer.Blit" );
}
tmpsurface.SafeDispose();
tmptex.SafeDispose();
return;
}
}
// Otherwise, try the normal method
var res2 = D3D9.Surface.FromSurface( dstBufferResources.Surface, srcBufferResources.Surface, D3D9.Filter.Default, 0,
dsrcRect, ddestRect );
if ( res2.Failure )
{
throw new AxiomException( "D3D9.Surface.FromSurface failed in D3D9HardwarePixelBuffer.Blit" );
}
}
else if ( dstBufferResources.Volume != null && srcBufferResources.Volume != null )
{
// Volume-to-volume
var dsrcBox = ToD3DBox( srcBox );
var ddestBox = ToD3DBox( dstBox );
var res = D3D9.Volume.FromVolume( dstBufferResources.Volume, srcBufferResources.Volume, D3D9.Filter.Default, 0,
dsrcBox, ddestBox );
if ( res.Failure )
{
throw new AxiomException( "D3D9.Volume.FromVolume failed in D3D9HardwarePixelBuffer.Blit" );
}
}
else
{
// Software fallback
base.Blit( rsrc, srcBox, dstBox );
}
}
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 RenderTexture( HardwarePixelBuffer buffer, int zOffset )
:this(string.Empty, buffer, zOffset)
{
}
///<summary>
/// Copies a box from another PixelBuffer to a region of the
/// this PixelBuffer.
///</summary>
///<param name="src">Source/dest pixel buffer</param>
///<param name="srcBox">Image.BasicBox describing the source region in this buffer</param>
///<param name="dstBox">Image.BasicBox describing the destination region in this buffer</param>
///<remarks>
/// The source and destination regions dimensions don't have to match, in which
/// case scaling is done. This scaling is generally done using a bilinear filter in hardware,
/// but it is faster to pass the source image in the right dimensions.
/// Only call this function when both buffers are unlocked.
///</remarks>
public override void Blit( HardwarePixelBuffer src, BasicBox srcBox, BasicBox dstBox )
{
D3DHardwarePixelBuffer _src = (D3DHardwarePixelBuffer)src;
if ( surface != null && _src.surface != null )
{
// Surface-to-surface
System.Drawing.Rectangle dsrcRect = ToD3DRectangle( srcBox );
System.Drawing.Rectangle ddestRect = ToD3DRectangle( dstBox );
// D3DXLoadSurfaceFromSurface
D3D.Surface.FromSurface( surface, _src.surface, D3D.Filter.None, 0, dsrcRect, ddestRect );
}
else if ( volume != null && _src.volume != null )
{
// Volume-to-volume
D3D.Box dsrcBox = ToD3DBox( srcBox );
D3D.Box ddestBox = ToD3DBox( dstBox );
// D3DXLoadVolumeFromVolume
D3D.Volume.FromVolume( volume, _src.volume, D3D.Filter.None, 0, dsrcBox, ddestBox );
}
else
// Software fallback
base.Blit( _src, srcBox, dstBox );
}
/// <summary>
///
/// </summary>
/// <param name="src"></param>
/// <param name="srcBox"></param>
/// <param name="dstBox"></param>
public override void Blit( HardwarePixelBuffer src, BasicBox srcBox, BasicBox dstBox )
{
GLESTextureBuffer 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 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 void Blit(HardwarePixelBuffer src)
{
Blit(src, new BasicBox(0, 0, 0, src.Width, src.Height, src.Depth),
new BasicBox(0, 0, 0, this.width, this.height, this.depth));
}
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();
}
///<summary>
/// Copies a box from another PixelBuffer to a region of the
/// this PixelBuffer.
///</summary>
///<param name="src">Source/dest pixel buffer</param>
///<param name="srcBox">Image.BasicBox describing the source region in this buffer</param>
///<param name="dstBox">Image.BasicBox describing the destination region in this buffer</param>
///<remarks>
/// The source and destination regions dimensions don't have to match, in which
/// case scaling is done. This scaling is generally done using a bilinear filter in hardware,
/// but it is faster to pass the source image in the right dimensions.
/// Only call this function when both buffers are unlocked.
///</remarks>
public virtual void Blit(HardwarePixelBuffer src, BasicBox srcBox, BasicBox dstBox)
{
if(IsLocked || src.IsLocked)
throw new Exception("Source and destination buffer may not be locked! In HardwarePixelBuffer.Blit");
if(src == this)
throw new Exception("Source must not be the same object, in HardwarePixelBuffer.Blit");
PixelBox srclock = src.Lock(srcBox, BufferLocking.ReadOnly);
BufferLocking method = BufferLocking.Normal;
if(dstBox.Left == 0 && dstBox.Top == 0 && dstBox.Front == 0 &&
dstBox.Right == width && dstBox.Bottom == height &&
dstBox.Back == depth)
// Entire buffer -- we can discard the previous contents
method = BufferLocking.Discard;
PixelBox dstlock = Lock(dstBox, method);
if(dstlock.Width != srclock.Width || dstlock.Height != srclock.Height || dstlock.Depth != srclock.Depth)
// Scaling desired
throw new Exception("Image scaling not yet implemented; in HardwarePixelBuffer.Blit");
// Image.Scale(srclock, dstlock);
else
// No scaling needed
PixelUtil.BulkPixelConversion(srclock, dstlock);
Unlock();
src.Unlock();
}
public D3DRenderTexture(string name, HardwarePixelBuffer buffer)
: base(buffer, 0)
{
this.name = name;
}
///<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);
}