text: import sys
  
  # Import renderdoc if not already imported (e.g. in the UI)
  if 'renderdoc' not in sys.modules and '_renderdoc' not in sys.modules:
  	import renderdoc
  
  # Alias renderdoc for legibility
  rd = renderdoc
  
  def loadCapture(filename):
  	# Open a capture file handle
  	cap = rd.OpenCaptureFile()
  
  	# Open a particular file - see also OpenBuffer to load from memory
  	status = cap.OpenFile(filename, '', None)
  
  	# Make sure the file opened successfully
  	if status != rd.ReplayStatus.Succeeded:
  		raise RuntimeError("Couldn't open file: " + str(status))
  
  	# Make sure we can replay
  	if not cap.LocalReplaySupport():
  		raise RuntimeError("Capture cannot be replayed")
  
  	# Initialise the replay
  	status,controller = cap.OpenCapture(rd.ReplayOptions(), None)
  
  	if status != rd.ReplayStatus.Succeeded:
  		raise RuntimeError("Couldn't initialise replay: " + str(status))
  
  	return cap,controller
  
  if 'pyrenderdoc' in globals():
  	raise RuntimeError("This sample should not be run within the RenderDoc UI")
  else:
  	if len(sys.argv) <= 1:
  		print('Usage: python3 {} filename.rdc'.format(sys.argv[0]))
  		sys.exit(0)
  
  	rd.InitialiseReplay(rd.GlobalEnvironment(), [])
  
  	cap,controller = loadCapture(sys.argv[1])
  
  # Use tkinter to create windows
  import tkinter
  
  # Create a simple window
  window = tkinter.Tk()
  window.geometry("1280x720")
  
  # Create renderdoc windowing data.
  winsystems = [rd.WindowingSystem(i) for i in controller.GetSupportedWindowSystems()]
  
  # Pass window system specific data here, See:
  # - renderdoc.CreateWin32WindowingData
  # - renderdoc.CreateXlibWindowingData
  # - renderdoc.CreateXCBWindowingData
  
  # This example code works on windows as that's simple to integrate with tkinter
  if not rd.WindowingSystem.Win32 in winsystems:
      raise RuntimeError("Example requires Win32 windowing system: " + str(winsystems))
  
  windata = rd.CreateWin32WindowingData(int(window.frame(), 16))
  
  # Create a texture output on the window
  out = controller.CreateOutput(windata, rd.ReplayOutputType.Texture)
  
  # Fetch the list of textures
  textures = controller.GetTextures()
  
  # Fetch the list of drawcalls
  draws = controller.GetDrawcalls()
  
  # Function to look up the texture descriptor for a given resourceId
  def getTexture(texid):
  	global textures
  	for tex in textures:
  		if tex.resourceId == texid:
  			return tex
  	return None
  
  # Our paint function will be called ever 33ms, to display the output
  def paint():
  	global out, window
  	out.Display()
  	window.after(33, paint)
  
  # Start on the first drawcall
  curdraw = draws[0]
  
  loopcount = 0
  
  # The advance function will be called every 50ms, to move to the next draw
  def advance():
  	global out, window, curdraw, draws, loopcount
  
  	# Move to the current drawcall
  	controller.SetFrameEvent(curdraw.eventId, False)
  
  	# Initialise a default TextureDisplay object
  	disp = rd.TextureDisplay()
  
  	# Set the first colour output as the texture to display
  	disp.resourceId = curdraw.outputs[0]
  
  	if disp.resourceId != rd.ResourceId.Null():
  		# Get the details of this texture
  		texDetails = getTexture(disp.resourceId)
  
  		# Calculate the scale required in width and height
  		widthScale = window.winfo_width() / texDetails.width
  		heightScale = window.winfo_height() / texDetails.height
  
  		# Use the lower scale to fit the texture on the window
  		disp.scale = min(widthScale, heightScale)
  
  		# Update the texture display
  		out.SetTextureDisplay(disp)
  
  	# Set the next drawcall
  	curdraw = curdraw.next
  
  	# If we have no next draw, start again from the first
  	if curdraw is None:
  		loopcount = loopcount + 1
  		curdraw = draws[0]
  
  	# after 3 loops, quit
  	if loopcount == 3:
  		window.quit()
  	else:
  		window.after(50, advance)
  
  # Start the callbacks
  advance()
  paint()
  
  # Start the main window loop
  window.mainloop()
  
  controller.Shutdown()
  
  cap.Shutdown()
  
  if 'pyrenderdoc' not in globals():
  	rd.ShutdownReplay()
  