C++ RDCEraseEl函数代码示例

D3D12RenderState::D3D12RenderState()
{
  views.clear();
  scissors.clear();

  rts.clear();
  rtSingle = false;
  dsv = PortableHandle();

  m_ResourceManager = NULL;

  heaps.clear();

  pipe = graphics.rootsig = compute.rootsig = ResourceId();
  graphics.sigelems.clear();
  compute.sigelems.clear();

  topo = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;

  stencilRef = 0;
  RDCEraseEl(blendFactor);

  RDCEraseEl(ibuffer);
  vbuffers.clear();
}

 ShaderDebugTrace DebugPixel(uint32_t eventID, uint32_t x, uint32_t y, uint32_t sample,
                             uint32_t primitive)
 {
   ShaderDebugTrace ret;
   RDCEraseEl(ret);
   return ret;
 }

 ShaderDebugTrace DebugVertex(uint32_t eventID, uint32_t vertid, uint32_t instid, uint32_t idx,
                              uint32_t instOffset, uint32_t vertOffset)
 {
   ShaderDebugTrace ret;
   RDCEraseEl(ret);
   return ret;
 }

Socket *CreateServerSocket(const char *bindaddr, uint16_t port, int queuesize)
{
	SOCKET s = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_NO_HANDLE_INHERIT);

	if(s == INVALID_SOCKET)
		return NULL;

	sockaddr_in addr;
	RDCEraseEl(addr);

	addr.sin_family = AF_INET;
	inet_pton(AF_INET, bindaddr, &addr.sin_addr);
	addr.sin_port = htons(port);

	int result = bind(s, (SOCKADDR *)&addr, sizeof(addr));
	if(result == SOCKET_ERROR)
	{
		RDCWARN("Failed to bind to %s:%d - %d", bindaddr, port, WSAGetLastError());
		closesocket(s);
		return NULL;
	}

	result = listen(s, queuesize);
	if(result == SOCKET_ERROR)
	{
		RDCWARN("Failed to listen on %s:%d - %d", bindaddr, port, WSAGetLastError());
		closesocket(s);
		return NULL;
	}
	
	u_long nonblock = 1;
	ioctlsocket(s, FIONBIO, &nonblock);

	return new Socket((ptrdiff_t)s);
}

ReplayOutput::ReplayOutput(ReplayRenderer *parent, void *w)
{
	m_pRenderer = parent;

	m_MainOutput.dirty = true;

	m_OverlayDirty = true;

	m_pDevice = parent->GetDevice();

	m_OverlayResourceId = ResourceId();

	RDCEraseEl(m_RenderData);
	
	m_PixelContext.wndHandle = 0;
	m_PixelContext.outputID = 0;
	m_PixelContext.texture = ResourceId();
	m_PixelContext.depthMode = false;

	m_ContextX = -1.0f;
	m_ContextY = -1.0f;

	m_Config.m_Type = eOutputType_None;

	if(w) m_MainOutput.outputID = m_pDevice->MakeOutputWindow(w, true);
	else m_MainOutput.outputID = 0;
	m_MainOutput.texture = ResourceId();
	
	m_pDevice->GetOutputWindowDimensions(m_MainOutput.outputID, m_Width, m_Height);

	m_FirstDeferredEvent = 0;
	m_LastDeferredEvent = 0;

	m_CustomShaderResourceId = ResourceId();
}

  ImageViewer(IReplayDriver *proxy, const char *filename)
      : m_Proxy(proxy), m_Filename(filename), m_TextureID()
  {
    if(m_Proxy == NULL)
      RDCERR("Unexpectedly NULL proxy at creation of ImageViewer");

    m_Props.pipelineType = ePipelineState_D3D11;
    m_Props.degraded = false;

    m_FrameRecord.frameInfo.fileOffset = 0;
    m_FrameRecord.frameInfo.firstEvent = 1;
    m_FrameRecord.frameInfo.frameNumber = 1;
    m_FrameRecord.frameInfo.immContextId = ResourceId();
    RDCEraseEl(m_FrameRecord.frameInfo.stats);

    create_array_uninit(m_FrameRecord.drawcallList, 1);
    FetchDrawcall &d = m_FrameRecord.drawcallList[0];
    d.context = ResourceId();
    d.drawcallID = 1;
    d.eventID = 1;
    d.name = filename;

    RefreshFile();

    create_array_uninit(m_PipelineState.m_OM.RenderTargets, 1);
    m_PipelineState.m_OM.RenderTargets[0].Resource = m_TextureID;
  }

void Win32CallstackResolver::OpenPdblocateHandle()
{
  STARTUPINFOW si;
  RDCEraseEl(si);

  PROCESS_INFORMATION pi;
  RDCEraseEl(pi);

  wchar_t locateCmd[128] = {0};

  wcscpy_s(locateCmd, L"\".\\pdblocate\\pdblocate.exe\"");

  BOOL success = CreateProcessW(NULL, locateCmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);

  if(!success)
    return;

  Sleep(100);

  CloseHandle(pi.hThread);

  pdblocateProcess = pi.hProcess;

  pdblocatePipe = CreateFileW(L"\\\\.\\pipe\\RenderDoc.pdblocate", GENERIC_READ | GENERIC_WRITE, 0,
                              NULL, OPEN_EXISTING, 0, NULL);

  if(pdblocatePipe == INVALID_HANDLE_VALUE)
  {
    RDCERR("Couldn't open pdblocate pipe");
    CloseHandle(pdblocatePipe);
    pdblocatePipe = NULL;
    return;
  }

  DWORD mode = PIPE_READMODE_MESSAGE;
  success = SetNamedPipeHandleState(pdblocatePipe, &mode, NULL, NULL);

  if(!success)
  {
    RDCERR("Couldn't set pdblocate pipe to message mode");
    CloseHandle(pdblocatePipe);
    pdblocatePipe = NULL;
    return;
  }
}

PostVSMeshData GLReplay::GetPostVSBuffers(uint32_t frameID, uint32_t eventID, MeshDataStage stage)
{
	PostVSMeshData ret;
	RDCEraseEl(ret);

	GLNOTIMP("GLReplay::GetPostVSBuffers");

	return ret;
}

		OpenGLHook()
		{
			LibraryHooks::GetInstance().RegisterHook("libGL.so", this);
			
			RDCEraseEl(GL);

			m_GLDriver = NULL;

			m_EnabledHooks = true;
			m_PopulatedHooks = false;
		}

	string GetReplayAppFilename()
	{
		HMODULE hModule = NULL;
		GetModuleHandleEx(
			GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS|GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
			(LPCTSTR)&dllLocator,
			&hModule);
		wchar_t curFile[512] = {0};
		GetModuleFileNameW(hModule, curFile, 511);

		string path = StringFormat::Wide2UTF8(wstring(curFile));
		path = dirname(path);
		string exe = path + "/renderdocui.exe";

		FILE *f = FileIO::fopen(exe.c_str(), "rb");
		if(f)
		{
			FileIO::fclose(f);
			return exe;
		}

		// if renderdocui.exe doesn't live in the same dir, we must be in x86/
		// so look one up the tree.
		exe = path + "/../renderdocui.exe";

		f = FileIO::fopen(exe.c_str(), "rb");
		if(f)
		{
			FileIO::fclose(f);
			return exe;
		}

		// if we didn't find the exe at all, we must not be in a standard
		// distributed renderdoc package. On windows we can check in the registry
		// to try and find the installed path.

		DWORD type = 0;
		DWORD dataSize = sizeof(curFile);
		RDCEraseEl(curFile);
		RegGetValueW(HKEY_CLASSES_ROOT, L"RenderDoc.RDCCapture.1\\DefaultIcon", NULL, RRF_RT_ANY,
			&type, (void *)curFile, &dataSize);

		if(type == REG_EXPAND_SZ || type == REG_SZ)
		{
			return StringFormat::Wide2UTF8(wstring(curFile));
		}

		return "";
	}

bool ReplayOutput::PickPixel(ResourceId tex, bool customShader, uint32_t x, uint32_t y,
                             uint32_t sliceFace, uint32_t mip, uint32_t sample, PixelValue *ret)
{
  if(ret == NULL || tex == ResourceId())
    return false;

  RDCEraseEl(ret->value_f);

  bool decodeRamp = false;

  FormatComponentType typeHint = m_RenderData.texDisplay.typeHint;

  if(customShader && m_RenderData.texDisplay.CustomShader != ResourceId() &&
     m_CustomShaderResourceId != ResourceId())
  {
    tex = m_CustomShaderResourceId;
    typeHint = eCompType_None;
  }
  if((m_RenderData.texDisplay.overlay == eTexOverlay_QuadOverdrawDraw ||
      m_RenderData.texDisplay.overlay == eTexOverlay_QuadOverdrawPass) &&
     m_OverlayResourceId != ResourceId())
  {
    decodeRamp = true;
    tex = m_OverlayResourceId;
    typeHint = eCompType_None;
  }

  m_pDevice->PickPixel(m_pDevice->GetLiveID(tex), x, y, sliceFace, mip, sample, typeHint,
                       ret->value_f);

  if(decodeRamp)
  {
    for(size_t c = 0; c < ARRAY_COUNT(overdrawRamp); c++)
    {
      if(fabs(ret->value_f[0] - overdrawRamp[c].x) < 0.00005f &&
         fabs(ret->value_f[1] - overdrawRamp[c].y) < 0.00005f &&
         fabs(ret->value_f[2] - overdrawRamp[c].z) < 0.00005f)
      {
        ret->value_i[0] = (int32_t)c;
        ret->value_i[1] = 0;
        ret->value_i[2] = 0;
        ret->value_i[3] = 0;
        break;
      }
    }
  }

  return true;
}

		bool CreateHooks(const char *libName)
		{
			RDCEraseEl(GL);

			if(!m_EnabledHooks)
				return false;
			
			bool success = SetupHooks();

			if(!success) return false;
			
			m_HasHooks = true;

			return true;
		}

ReplayOutput::ReplayOutput(ReplayRenderer *parent, WindowingSystem system, void *data, OutputType type)
{
  m_pRenderer = parent;

  m_MainOutput.dirty = true;

  m_OverlayDirty = true;
  m_ForceOverlayRefresh = false;

  m_pDevice = parent->GetDevice();

  m_EventID = parent->m_EventID;

  m_OverlayResourceId = ResourceId();

  RDCEraseEl(m_RenderData);

  m_PixelContext.outputID = 0;
  m_PixelContext.texture = ResourceId();
  m_PixelContext.depthMode = false;

  m_ContextX = -1.0f;
  m_ContextY = -1.0f;

  m_Config.m_Type = type;

  if(system != eWindowingSystem_Unknown)
    m_MainOutput.outputID =
        m_pDevice->MakeOutputWindow(system, data, type == eOutputType_MeshDisplay);
  else
    m_MainOutput.outputID = 0;
  m_MainOutput.texture = ResourceId();

  m_pDevice->GetOutputWindowDimensions(m_MainOutput.outputID, m_Width, m_Height);

  m_FirstDeferredEvent = 0;
  m_LastDeferredEvent = 0;

  m_CustomShaderResourceId = ResourceId();
}

Socket *CreateServerSocket(const char *bindaddr, uint16_t port, int queuesize)
{
	int s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	if(s == -1)
		return NULL;

	sockaddr_in addr;
	RDCEraseEl(addr);

	hostent *hp = gethostbyname(bindaddr);

	addr.sin_family = AF_INET;
	memcpy(&addr.sin_addr, hp->h_addr, hp->h_length);
	addr.sin_port = htons(port);

	int result = bind(s, (sockaddr *)&addr, sizeof(addr));
	if(result == -1)
	{
		RDCWARN("Failed to bind to %s:%d - %d", bindaddr, port, errno);
		close(s);
		return NULL;
	}

	result = listen(s, queuesize);
	if(result == -1)
	{
		RDCWARN("Failed to listen on %s:%d - %d", bindaddr, port, errno);
		close(s);
		return NULL;
	}
	
	int flags = fcntl(s, F_GETFL, 0);
	fcntl(s, F_SETFL, flags | O_NONBLOCK);

	return new Socket((ptrdiff_t)s);
}

//.........这里部分代码省略.........
		cullMode = pCreateInfo->pRasterizationState->cullMode;
		frontFace = pCreateInfo->pRasterizationState->frontFace;
		depthBiasEnable = pCreateInfo->pRasterizationState->depthBiasEnable ? true : false;
		depthBiasConstantFactor = pCreateInfo->pRasterizationState->depthBiasConstantFactor;
		depthBiasClamp = pCreateInfo->pRasterizationState->depthBiasClamp;
		depthBiasSlopeFactor = pCreateInfo->pRasterizationState->depthBiasSlopeFactor;
		lineWidth = pCreateInfo->pRasterizationState->lineWidth;

		// VkPipelineMultisampleStateCreateInfo
		if(pCreateInfo->pMultisampleState)
		{
			rasterizationSamples = pCreateInfo->pMultisampleState->rasterizationSamples;
			sampleShadingEnable = pCreateInfo->pMultisampleState->sampleShadingEnable ? true : false;
			minSampleShading = pCreateInfo->pMultisampleState->minSampleShading;
			sampleMask = pCreateInfo->pMultisampleState->pSampleMask ? *pCreateInfo->pMultisampleState->pSampleMask : ~0U;
			alphaToCoverageEnable = pCreateInfo->pMultisampleState->alphaToCoverageEnable ? true : false;
			alphaToOneEnable = pCreateInfo->pMultisampleState->alphaToOneEnable ? true : false;
		}
		else
		{
			rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
			sampleShadingEnable = false;
			minSampleShading = 1.0f;
			sampleMask = ~0U;
			alphaToCoverageEnable = false;
			alphaToOneEnable = false;
		}

		// VkPipelineDepthStencilStateCreateInfo
		if(pCreateInfo->pDepthStencilState)
		{
			depthTestEnable = pCreateInfo->pDepthStencilState->depthTestEnable ? true : false;
			depthWriteEnable = pCreateInfo->pDepthStencilState->depthWriteEnable ? true : false;
			depthCompareOp = pCreateInfo->pDepthStencilState->depthCompareOp;
			depthBoundsEnable = pCreateInfo->pDepthStencilState->depthBoundsTestEnable ? true : false;
			stencilTestEnable = pCreateInfo->pDepthStencilState->stencilTestEnable ? true : false;
			front = pCreateInfo->pDepthStencilState->front;
			back = pCreateInfo->pDepthStencilState->back;
			minDepthBounds = pCreateInfo->pDepthStencilState->minDepthBounds;
			maxDepthBounds = pCreateInfo->pDepthStencilState->maxDepthBounds;
		}
		else
		{
			depthTestEnable = false;
			depthWriteEnable = false;
			depthCompareOp = VK_COMPARE_OP_ALWAYS;
			depthBoundsEnable = false;
			stencilTestEnable = false;
			front.failOp = VK_STENCIL_OP_KEEP;
			front.passOp = VK_STENCIL_OP_KEEP;
			front.depthFailOp = VK_STENCIL_OP_KEEP;
			front.compareOp = VK_COMPARE_OP_ALWAYS;
			front.compareMask = 0xff;
			front.writeMask = 0xff;
			front.reference = 0;
			back = front;
			minDepthBounds = 0.0f;
			maxDepthBounds = 1.0f;
		}

		// VkPipelineColorBlendStateCreateInfo
		if(pCreateInfo->pColorBlendState)
		{
			logicOpEnable = pCreateInfo->pColorBlendState->logicOpEnable ? true : false;
			logicOp = pCreateInfo->pColorBlendState->logicOp;
			memcpy(blendConst, pCreateInfo->pColorBlendState->blendConstants, sizeof(blendConst));

			attachments.resize(pCreateInfo->pColorBlendState->attachmentCount);

			for(uint32_t i=0; i < pCreateInfo->pColorBlendState->attachmentCount; i++)
			{
				attachments[i].blendEnable = pCreateInfo->pColorBlendState->pAttachments[i].blendEnable ? true : false;

				attachments[i].blend.Source = pCreateInfo->pColorBlendState->pAttachments[i].srcColorBlendFactor;
				attachments[i].blend.Destination = pCreateInfo->pColorBlendState->pAttachments[i].dstColorBlendFactor;
				attachments[i].blend.Operation = pCreateInfo->pColorBlendState->pAttachments[i].colorBlendOp;

				attachments[i].alphaBlend.Source = pCreateInfo->pColorBlendState->pAttachments[i].srcAlphaBlendFactor;
				attachments[i].alphaBlend.Destination = pCreateInfo->pColorBlendState->pAttachments[i].dstAlphaBlendFactor;
				attachments[i].alphaBlend.Operation = pCreateInfo->pColorBlendState->pAttachments[i].alphaBlendOp;

				attachments[i].channelWriteMask = (uint8_t)pCreateInfo->pColorBlendState->pAttachments[i].colorWriteMask;
			}
		}
		else
		{
			logicOpEnable = false;
			logicOp = VK_LOGIC_OP_NO_OP;
			RDCEraseEl(blendConst);

			attachments.clear();
		}

		RDCEraseEl(dynamicStates);
		if(pCreateInfo->pDynamicState)
		{
			for(uint32_t i=0; i < pCreateInfo->pDynamicState->dynamicStateCount; i++)
				dynamicStates[ pCreateInfo->pDynamicState->pDynamicStates[i] ] = true;
		}
}