static void Main(string[] args)
{
InitGraphics();
for (int i = 0; i < args.Length; ++i)
{
string arg = args[i];
arg = arg.Substring(arg.LastIndexOf('\\') + 1, arg.Length - arg.LastIndexOf('\\') - 1);
if (File.Exists(arg))
{
try
{
Texture2D src = Texture2D.FromStream(GraphicsDevice, File.OpenRead(arg));
Texture2D dest = new Texture2D(GraphicsDevice, src.Width >> 1, src.Height >> 1);
Color[] src_pix = new Color[src.Width * src.Height];
Color[] dest_pix = new Color[dest.Width * dest.Height];
src.GetData<Color>(src_pix);
for (int j = 0; j < dest.Width; ++j)
{
for (int k = 0; k < dest.Height; ++k)
{
dest_pix[(k * dest.Width) + j] = src_pix[((k<<1) * src.Width) + (j<<1)];
}
}
dest.SetData<Color>(dest_pix);
dest.SaveAsJpeg(File.OpenWrite("h_" + arg), dest.Width, dest.Height);
}
catch (Exception e)
{
}
}
}
}
public static void TakeScreenShot(GraphicsDevice device, Keys theKey)
{
currentState = Keyboard.GetState();
if (currentState.IsKeyDown(theKey) && preState.IsKeyUp(theKey))
{
byte[] screenData;
screenData = new byte[device.PresentationParameters.BackBufferWidth * device.PresentationParameters.BackBufferHeight * 4];
device.GetBackBufferData<byte>(screenData);
Texture2D Screenshot = new Texture2D(device, device.PresentationParameters.BackBufferWidth, device.PresentationParameters.BackBufferHeight, false, device.PresentationParameters.BackBufferFormat);
Screenshot.SetData<byte>(screenData);
string name = "Screenshot_" + counter + ".jpeg";
while (File.Exists(name))
{
counter += 1;
name = "Screenshot_" + counter + ".jpeg";
}
Stream stream = new FileStream(name, FileMode.Create);
Screenshot.SaveAsJpeg(stream, Screenshot.Width, Screenshot.Height);
stream.Close();
Screenshot.Dispose();
}
preState = currentState;
}
/// <summary>
/// Stores the current contents of the back buffer as a .PNG file.
/// </summary>
/// <param name="inGraphicsDevice">GraphicsDevice to grab the back buffer data from.</param>
/// <param name="inFilename">String containing the name of the file to save.</param>
/// <returns>True if the file is saved successfully, otherwise false.</returns>
public static bool Capture(GraphicsDevice inGraphicsDevice,
String inFilename, ScreenCaptureType inCaptureExtension)
{
if (inCaptureExtension == ScreenCaptureType.UseJPEG) { inFilename = inFilename + ".jpg"; }
if (inCaptureExtension == ScreenCaptureType.UsePNG) { inFilename = inFilename + ".png"; }
// Store the current BackBuffer data in a new array of Color values. This
// will take what is currently on the BackBuffer; everything current being
// drawn to the screen.
Color[] colorData = new Color[inGraphicsDevice.Viewport.Width *
inGraphicsDevice.Viewport.Height];
inGraphicsDevice.GetBackBufferData<Color>(colorData);
// Next set the colors into a Texture, ready for saving.
Texture2D backBufferTexture = new Texture2D(inGraphicsDevice,
inGraphicsDevice.Viewport.Width,
inGraphicsDevice.Viewport.Height);
backBufferTexture.SetData<Color>(colorData, 0, colorData.Length);
// Create the file after checking whether it exists. This requires a means
// of altering the intended filename so that it cannot overwrite an existing
// screen-capture, for instance suffixing an incremental digit onto the file
// name, but this would have to be saved to avoid overwritten files when the
// game crashes and the count is lost.
if (!File.Exists(inFilename))
{
using (FileStream fileStream = File.Create(inFilename))
{
// The choice passed in as the 3rd parameter just exists for the sake
// of providing options. If one is clearly advantageous to the other
// I'll hard-code it to use that instead. But, for now, we allow the
// choice between JPEG and PNG. PNG files have transparency.
switch (inCaptureExtension)
{
case ScreenCaptureType.UseJPEG:
backBufferTexture.SaveAsJpeg(fileStream,
inGraphicsDevice.Viewport.Width,
inGraphicsDevice.Viewport.Height);
break;
case ScreenCaptureType.UsePNG:
backBufferTexture.SaveAsPng(fileStream,
inGraphicsDevice.Viewport.Width,
inGraphicsDevice.Viewport.Height);
break;
}
fileStream.Flush();
}
return true;
}
return false;
}
public static BitmapImage Texture2Image(Texture2D texture)
{
try
{
if (texture == null)
{
return null;
}
if (texture.IsDisposed)
{
return null;
}
//Memory stream to store the bitmap data.
MemoryStream ms = new MemoryStream();
//Save the texture to the stream.
texture.SaveAsJpeg(ms, texture.Width, texture.Height);
ms.Seek(0, SeekOrigin.Begin);
byte[] bytes = ms.ToArray();
BitmapImage bi = new BitmapImage();
bi.BeginInit();
bi.StreamSource = new MemoryStream(bytes);
bi.EndInit();
//Close the stream, we nolonger need it.
ms.Close();
ms = null;
return bi;
}
catch (System.Exception ex)
{
throw ex;
}
}
public static bool CaptureJpeg(GraphicsDevice inGraphicsDevice, String inFilename)
{
inFilename = inFilename + ".jpeg";
// Store the current BackBuffer data in a new array of Color values. This
// will take what is currently on the BackBuffer; everything current being
// drawn to the screen.
Color[] colorData = new Color[inGraphicsDevice.Viewport.Width *
inGraphicsDevice.Viewport.Height];
inGraphicsDevice.GetBackBufferData<Color>(colorData);
// Next set the colors into a Texture, ready for saving.
Texture2D backBufferTexture = new Texture2D(inGraphicsDevice,
inGraphicsDevice.Viewport.Width,
inGraphicsDevice.Viewport.Height);
backBufferTexture.SetData<Color>(colorData, 0, colorData.Length);
// Create the file after checking whether it exists. This requires a means
// of altering the intended filename so that it cannot overwrite an existing
// screen-capture, for instance suffixing an incremental digit onto the file
// name, but this would have to be saved to avoid overwritten files when the
// game crashes and the count is lost.
if (!File.Exists(inFilename))
{
using (FileStream fileStream = File.Create(inFilename))
{
backBufferTexture.SaveAsJpeg(fileStream,
inGraphicsDevice.Viewport.Width,
inGraphicsDevice.Viewport.Height);
fileStream.Flush();
}
return true;
}
return false;
}
internal static byte[] Texture2DToBytes(Texture2D thumb)
{
MemoryStream s = new MemoryStream();
thumb.SaveAsJpeg(s, thumb.Width, thumb.Height);
byte[] data = new byte[s.Length];
s.Position = 0;
s.Read(data, 0, data.Length);
s.Dispose();
return data;
}
private void Save(Texture2D texture, string name)
{
using (Stream stream = File.Create(name))
texture.SaveAsJpeg(stream, texture.Width, texture.Height);
}
private void ProcessImage( string outputDir )
{
string outfileBase = outputDir + @"\" + txtOutFileBaseName.Text;
Rectangle frame = new Rectangle( 0, 0, (int)nudCutWidth.Value, (int)nudCutHeight.Value );
Texture2D workingImg = new Texture2D( gd, frame.Width, frame.Height );
int count = 0;
int numRows = originalImg.Height / frame.Height;
int numCols = originalImg.Width / frame.Width;
int numPixels = frame.Width * frame.Height;
for ( int i = 0; i < numRows; i++ )
{
frame.Y = i * frame.Height;
for ( int j = 0; j < numCols; j++ )
{
frame.X = j * frame.Width;
Color[] cpy = new Color[numPixels];
originalImg.GetData<Color>( 0, frame, cpy, 0, numPixels );
workingImg.SetData<Color>( cpy );
// Save the image
Stream s;
switch ( cmbOutFileType.SelectedIndex )
{
case 0:
s = File.OpenWrite( outfileBase + count.ToString() + ".png" );
workingImg.SaveAsPng( s, workingImg.Width, workingImg.Height );
s.Close();
break;
case 1:
s = File.OpenWrite( outfileBase + count.ToString() + ".jpg" );
workingImg.SaveAsJpeg( s, workingImg.Width, workingImg.Height );
s.Close();
break;
default:
break;
}
count++;
}
}
MessageBox.Show( "Created " + count.ToString() + " tiles!", "Processing Done!" );
}
protected void SaveTexture(Texture2D texture, string name)
{
FileStream stream = new FileStream(name, FileMode.Create);
texture.SaveAsJpeg(stream, texture.Width, texture.Height);
stream.Close();
}
private void MakeScreenshot()
{
try
{
//NOTE: This doesn't always work on all cards, especially if
// desktop mode switches in fullscreen mode!
screenshotNum++;
// Make sure screenshots directory exists
if (Directory.Exists(Directories.ScreenshotsDirectory) == false)
Directory.CreateDirectory(Directories.ScreenshotsDirectory);
int width = BaseGame.Device.PresentationParameters.BackBufferWidth;
int height = BaseGame.Device.PresentationParameters.BackBufferHeight;
using (
var tex = new Texture2D(BaseGame.Device, width, height, false,
BaseGame.Device.PresentationParameters.BackBufferFormat))
{
int[] backbuffer = new int[width*height];
BaseGame.Device.GetBackBufferData(backbuffer);
tex.SetData(backbuffer);
FileHelper.StorageContainerMRE.WaitOne();
FileHelper.StorageContainerMRE.Reset();
// Open a storage container
StorageDevice storageDevice = FileHelper.XnaUserDevice;
if ((storageDevice != null) && storageDevice.IsConnected)
{
IAsyncResult async = storageDevice.BeginOpenContainer("RacingGame", null, null);
async.AsyncWaitHandle.WaitOne();
using (StorageContainer container = storageDevice.EndOpenContainer(async))
{
async.AsyncWaitHandle.Close();
using (Stream stream = container.CreateFile(ScreenshotNameBuilder(screenshotNum)))
{
tex.SaveAsJpeg(stream, width, height);
}
}
}
}
}
catch (Exception ex)
{
Log.Write("Failed to save Screenshot: " + ex.ToString());
}
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
_screens.PrepareDraw();
_screens.Draw(gameTime);
if (DisplayUI)
_ui.Draw(gameTime);
//var model = Content.Load<Model>("Sponza");
//GraphicsDevice.DepthStencilState = DepthStencilState.Default;
//GraphicsDevice.BlendState = BlendState.Opaque;
//GraphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise;
//GraphicsDevice.SamplerStates[0] = SamplerState.LinearWrap;
//GraphicsDevice.SamplerStates[1] = SamplerState.LinearWrap;
//GraphicsDevice.SamplerStates[2] = SamplerState.LinearWrap;
//// Calculate aspect ratio
//float aspectRatio = (float)GraphicsDevice.Viewport.Width / GraphicsDevice.Viewport.Height;
//// Animated the model rotating
//float modelRotation = (float)gameTime.TotalGameTime.TotalSeconds / 5.0f;
//// Set the positions of the camera in world space, for our view matrix.
//Vector3 cameraPosition = new Vector3(0.0f, 50.0f, -200.0f);
//Vector3 lookAt = new Vector3(0.0f, 40.0f, 300.0f);
//// Copy any parent transforms.
//Matrix[] transforms = new Matrix[model.Bones.Count];
//model.CopyAbsoluteBoneTransformsTo(transforms);
//// Draw the model. A model can have multiple meshes, so loop.
//foreach (ModelMesh mesh in model.Meshes)
//{
// // This is where the mesh orientation is set,
// // as well as our camera and projection.
// foreach (BasicEffect effect in mesh.Effects)
// {
// effect.EnableDefaultLighting();
// effect.World =
// Matrix.CreateScale(1) *
// transforms[mesh.ParentBone.Index] *
// Matrix.CreateRotationY(modelRotation);
// effect.View = Matrix.CreateLookAt(cameraPosition, lookAt,
// Vector3.Up);
// effect.Projection = Matrix.CreatePerspectiveFieldOfView(
// MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f);
// }
// // Draw the mesh, using the effects set above.
// mesh.Draw();
//}
base.Draw(gameTime);
var currentKeyboard = Keyboard.GetState();
if (currentKeyboard.IsKeyDown(Keys.PrintScreen) && _previousKeyboard.IsKeyUp(Keys.PrintScreen))
{
var pp = GraphicsDevice.PresentationParameters;
var data = new Color[pp.BackBufferWidth * pp.BackBufferHeight];
GraphicsDevice.GetBackBufferData(data);
// must be a less stupid way of doing this
var texture = new Texture2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight);
texture.SetData<Color>(data);
var filename = Path.Combine(Environment.CurrentDirectory, "screenshot.jpg");
using (var stream = File.Create(filename))
texture.SaveAsJpeg(stream, texture.Width, texture.Height);
}
_previousKeyboard = currentKeyboard;
}
public void SaveJpg(Texture2D tex, string name)
{
FileStream f = new FileStream(name, FileMode.Create);
tex.SaveAsJpeg(f, tex.Width, tex.Height);
f.Close();
}
