NearestFunc SamplerJitCache::Compile(const SamplerID &id) { BeginWrite(); const u8 *start = AlignCode16(); // Early exit on !srcPtr. FixupBranch zeroSrc; if (id.hasInvalidPtr) { CMP(PTRBITS, R(srcReg), Imm8(0)); FixupBranch nonZeroSrc = J_CC(CC_NZ); XOR(32, R(RAX), R(RAX)); zeroSrc = J(true); SetJumpTarget(nonZeroSrc); } if (!Jit_ReadTextureFormat(id)) { EndWrite(); SetCodePtr(const_cast<u8 *>(start)); return nullptr; } if (id.hasInvalidPtr) { SetJumpTarget(zeroSrc); } RET(); EndWrite(); return (NearestFunc)start; }
CLog& CLog::operator << (LOGLEVEL level) { if (level <= LOGLEVEL_NONE || level >= LOGLEVEL_MAX) { return *this; } //Lock(&m_StreamLock); m_nLogLevel = level; int nLen = strlen(m_szBuff); if (nLen + 40 >= MAX_LOG) { EndWrite(); return *this; } time_t now = time(NULL); tm* pNow = localtime(&now); if (m_nMode & LOGMODE_YEAR) sprintf(m_szBuff, "%s[%04d-%02d-%02d %02d:%02d:%02d]", m_LogLevelString[level], 1900 + pNow->tm_year, 1 + pNow->tm_mon, pNow->tm_mday, pNow->tm_hour, pNow->tm_min, pNow->tm_sec); else sprintf(m_szBuff, "%s[%02d-%02d %02d:%02d:%02d]", m_LogLevelString[level], 1 + pNow->tm_mon, pNow->tm_mday, pNow->tm_hour, pNow->tm_min, pNow->tm_sec); return *this; }
CLog& CLog::operator<< (std::ostream& (*op) (std::ostream&)) { int nLen = strlen(m_szBuff); if (nLen + 1 < MAX_LOG) { sprintf(m_szBuff + nLen, "\n"); } EndWrite(); return *this; }
CLog& CLog::operator << (unsigned short n) { int nLen = strlen(m_szBuff); if (nLen + 6 >= MAX_LOG) { EndWrite(); return *this; } sprintf(m_szBuff + nLen, "%hu", n); return *this; }
CLog& CLog::operator << (unsigned char c) { int nLen = strlen(m_szBuff); if (nLen + 2 >= MAX_LOG) { EndWrite(); return *this; } sprintf(m_szBuff + nLen, "%c", c); return *this; }
CLog& CLog::operator << (float f) { int nLen = strlen(m_szBuff); if (nLen + 8 >= MAX_LOG) { EndWrite(); return *this; } sprintf(m_szBuff + nLen, "%f", f); return *this; }
/*! \fn swLabel::_renderText( const std::String& str ) */ bool swLabel::_renderText( const std::string& str ) { swWriter* sw = StartWrite(); sw->Clear(); sw->Position(0,0); /// @todo Have to render the text inside the label from the rules{ justification|wrapping|clipping } for now just write the text (*sw) << swWriter::text << str; EndWrite(); return true; }
CLog& CLog::operator << (long n) { int nLen = strlen(m_szBuff); if (nLen + 11 >= MAX_LOG) { EndWrite(); return *this; } sprintf(m_szBuff + nLen, "%ld", n); return *this; }
CLog& CLog::operator << (const int* p) { int nLen = strlen(m_szBuff); if (nLen + 11 >= MAX_LOG) { EndWrite(); return *this; } sprintf(m_szBuff + nLen, "%p", p); return *this; }
CLog& CLog::operator << (double d) { int nLen = strlen(m_szBuff); if (nLen + 20 >= MAX_LOG) { EndWrite(); return *this; } sprintf(m_szBuff + nLen, "%lf", d); return *this; }
CLog& CLog::operator << (const std::string& str) { int nLen = strlen(m_szBuff); int nInputLen = str.size(); if (nLen + nInputLen >= MAX_LOG) { EndWrite(); return *this; } sprintf(m_szBuff + nLen, "%s", str.c_str()); return *this; }
CLog& CLog::operator << (const char* str) { int nLen = strlen(m_szBuff); int nInputLen = strlen(str); if (nLen + nInputLen >= MAX_LOG) { EndWrite(); return *this; } sprintf(m_szBuff + nLen, "%s", str); return *this; }
void CPackFiles::Kill(void) { if (meMode == PFM_Read) { EndRead(); } else if (meMode == PFM_Write) { EndWrite(); } mcFile.Kill(); mcNames.Kill(); }
bool Pickle::WriteBytes(const void* data, int data_len) { DCHECK(capacity_ != kCapacityReadOnly) << "oops: pickle is readonly"; char* dest = BeginWrite(data_len); if(!dest) { return false; } memcpy(dest, data, data_len); EndWrite(dest, data_len); return true; }
CLog& CLog::operator << (bool b) { int nLen = strlen(m_szBuff); if (nLen + 6 >= MAX_LOG) { EndWrite(); return *this; } if (b) { sprintf(m_szBuff + nLen, "true"); } else { sprintf(m_szBuff + nLen, "false"); } return *this; }
char* Pickle::BeginWriteData(int length) { DCHECK_EQ(variable_buffer_offset_, 0U) << "There can only be one variable buffer in a Pickle"; if(length<0 || !WriteInt(length)) { return NULL; } char* data_ptr = BeginWrite(length); if(!data_ptr) { return NULL; } variable_buffer_offset_ = data_ptr - reinterpret_cast<char*>(header_) - sizeof(int); // 数据写入后不必要再调用EndWrite, 所以在这里调用进行数据对齐. EndWrite(data_ptr, length); return data_ptr; }
HRESULT CGraphics::Render(void) { if(!m_Device) return E_FAIL; if(m_NeedReset) return S_FALSE; HRESULT hr; if(FAILED(hr = m_Device->TestCooperativeLevel())) { TRACE(TEXT("Warning: Failed on test cooperative level.\n")); // The device has been lost but cannot be reset at this time. // Therefore, rendering is not possible and we'll have to return // and try again at a later time. if(hr == D3DERR_DEVICELOST) { TRACE(TEXT("Warning: Display device lost.\n")); return S_FALSE; } // The device has been lost but it can be reset at this time. if(hr == D3DERR_DEVICENOTRESET) { // Try to reset the device m_NeedReset = TRUE; return S_FALSE; } } if(SUCCEEDED(m_Device->BeginScene())) { if(SUCCEEDED(BeginWrite())) { //m_Direct3DBeginEvent(NULL,TEXT("Rendering")); if(!m_Blur) { m_Device->Clear(NULL,NULL,D3DCLEAR_TARGET,m_Background,1.0f,NULL); if(GetVisualizationCount() && GetVisualization(m_Visualization)) GetVisualization(m_Visualization)->Draw(*this); } else { LPDIRECT3DSURFACE9 backbufferTarget = NULL; m_Device->GetRenderTarget(0,&backbufferTarget); LPDIRECT3DSURFACE9 blurTarget = NULL; m_BlurTexture->GetSurfaceLevel(0,&blurTarget); m_Device->SetRenderTarget(0,blurTarget); m_Device->Clear(NULL,NULL,D3DCLEAR_TARGET,Color(0.0f,0.0f,0.0f,0.0f),1.0f,NULL); // Maybe this is faster //SpriteWrite(Rect(0.0f,0.0f,GetWidth()/2,GetHeight()/2),Color(1.0f,0.0f,0.0f,0.0f),NULL); SpriteWrite(Rect(0.0f,0.0f,GetWidth()/2,GetHeight()/2),Color(1.0f,1.0f,1.0f,1.0f),m_VisualizationTexture); SpriteFlush(); LineFlush(); LPDIRECT3DSURFACE9 visualizationTarget = NULL; m_VisualizationTexture->GetSurfaceLevel(0,&visualizationTarget); m_Device->SetRenderTarget(0,visualizationTarget); SpriteWrite(Rect(0.0f,0.0f,GetWidth(),GetHeight()),Color(1.0f,1.0f,1.0f,1.0f),m_BlurTexture); SpriteFlush(); m_Device->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA); m_Device->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE); m_Device->SetRenderState(D3DRS_BLENDOP,D3DBLENDOP_REVSUBTRACT); SpriteWrite(Rect(0.0f,0.0f,GetWidth(),GetHeight()),Color(max(0.0f,min(1.0f,GetElapsedTime()/50.0f)),1.0f,1.0f,1.0f),NULL); SpriteFlush(); m_Device->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA); m_Device->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA); m_Device->SetRenderState(D3DRS_BLENDOP,D3DBLENDOP_ADD); if(GetVisualizationCount() && GetVisualization(m_Visualization)) GetVisualization(m_Visualization)->Draw(*this); SpriteFlush(); LineFlush(); m_Device->SetRenderTarget(0,backbufferTarget); visualizationTarget->Release(); blurTarget->Release(); backbufferTarget->Release(); SpriteWrite(Rect(0.0f,0.0f,GetWidth(),GetHeight()),Color(1.0f,1.0f,1.0f,1.0f),m_VisualizationTexture); } EndWrite(); //m_Direct3DEndEvent(); } else { TRACE(TEXT("Error: Failed to begin sprite write.\n")); } m_Device->EndScene(); } else { TRACE(TEXT("Error: Failed to begin scene.\n")); } if(FAILED(m_Device->Present(NULL,NULL,NULL,NULL))) { TRACE(TEXT("Error: Failed to present scene.\n")); } return S_OK; }
LinearFunc SamplerJitCache::CompileLinear(const SamplerID &id) { _assert_msg_(G3D, id.linear, "Linear should be set on sampler id"); BeginWrite(); // We'll first write the nearest sampler, which we will CALL. // This may differ slightly based on the "linear" flag. const u8 *nearest = AlignCode16(); if (!Jit_ReadTextureFormat(id)) { EndWrite(); SetCodePtr(const_cast<u8 *>(nearest)); return nullptr; } RET(); // Now the actual linear func, which is exposed externally. const u8 *start = AlignCode16(); // NOTE: This doesn't use the general register mapping. // POSIX: arg1=uptr, arg2=vptr, arg3=frac_u, arg4=frac_v, arg5=src, arg6=bufw, stack+8=level // Win64: arg1=uptr, arg2=vptr, arg3=frac_u, arg4=frac_v, stack+40=src, stack+48=bufw, stack+56=level // // We map these to nearest CALLs, with order: u, v, src, bufw, level // Let's start by saving a bunch of registers. PUSH(R15); PUSH(R14); PUSH(R13); PUSH(R12); // Won't need frac_u/frac_v for a while. PUSH(arg4Reg); PUSH(arg3Reg); // Extra space to restore alignment and save resultReg for lerp. // TODO: Maybe use XMMs instead? SUB(64, R(RSP), Imm8(24)); MOV(64, R(R12), R(arg1Reg)); MOV(64, R(R13), R(arg2Reg)); #ifdef _WIN32 // First arg now starts at 24 (extra space) + 48 (pushed stack) + 8 (ret address) + 32 (shadow space) const int argOffset = 24 + 48 + 8 + 32; MOV(64, R(R14), MDisp(RSP, argOffset)); MOV(32, R(R15), MDisp(RSP, argOffset + 8)); // level is at argOffset + 16. #else MOV(64, R(R14), R(arg5Reg)); MOV(32, R(R15), R(arg6Reg)); // level is at 24 + 48 + 8. #endif // Early exit on !srcPtr. FixupBranch zeroSrc; if (id.hasInvalidPtr) { CMP(PTRBITS, R(R14), Imm8(0)); FixupBranch nonZeroSrc = J_CC(CC_NZ); XOR(32, R(RAX), R(RAX)); zeroSrc = J(true); SetJumpTarget(nonZeroSrc); } // At this point: // R12=uptr, R13=vptr, stack+24=frac_u, stack+32=frac_v, R14=src, R15=bufw, stack+X=level auto doNearestCall = [&](int off) { MOV(32, R(uReg), MDisp(R12, off)); MOV(32, R(vReg), MDisp(R13, off)); MOV(64, R(srcReg), R(R14)); MOV(32, R(bufwReg), R(R15)); // Leave level, we just always load from RAM. Separate CLUTs is uncommon. CALL(nearest); MOV(32, MDisp(RSP, off), R(resultReg)); }; doNearestCall(0); doNearestCall(4); doNearestCall(8); doNearestCall(12); // Convert TL, TR, BL, BR to floats for easier blending. if (!cpu_info.bSSE4_1) { PXOR(XMM0, R(XMM0)); } MOVD_xmm(fpScratchReg1, MDisp(RSP, 0)); MOVD_xmm(fpScratchReg2, MDisp(RSP, 4)); MOVD_xmm(fpScratchReg3, MDisp(RSP, 8)); MOVD_xmm(fpScratchReg4, MDisp(RSP, 12)); if (cpu_info.bSSE4_1) { PMOVZXBD(fpScratchReg1, R(fpScratchReg1)); PMOVZXBD(fpScratchReg2, R(fpScratchReg2)); PMOVZXBD(fpScratchReg3, R(fpScratchReg3)); PMOVZXBD(fpScratchReg4, R(fpScratchReg4)); } else { PUNPCKLBW(fpScratchReg1, R(XMM0)); PUNPCKLBW(fpScratchReg2, R(XMM0)); PUNPCKLBW(fpScratchReg3, R(XMM0)); PUNPCKLBW(fpScratchReg4, R(XMM0)); PUNPCKLWD(fpScratchReg1, R(XMM0)); PUNPCKLWD(fpScratchReg2, R(XMM0)); PUNPCKLWD(fpScratchReg3, R(XMM0)); PUNPCKLWD(fpScratchReg4, R(XMM0)); } CVTDQ2PS(fpScratchReg1, R(fpScratchReg1)); CVTDQ2PS(fpScratchReg2, R(fpScratchReg2)); CVTDQ2PS(fpScratchReg3, R(fpScratchReg3)); CVTDQ2PS(fpScratchReg4, R(fpScratchReg4)); // Okay, now multiply the R sides by frac_u, and L by (256 - frac_u)... MOVD_xmm(fpScratchReg5, MDisp(RSP, 24)); CVTDQ2PS(fpScratchReg5, R(fpScratchReg5)); SHUFPS(fpScratchReg5, R(fpScratchReg5), _MM_SHUFFLE(0, 0, 0, 0)); if (RipAccessible(by256)) { MULPS(fpScratchReg5, M(by256)); // rip accessible } else { Crash(); // TODO } MOVAPS(XMM0, M(ones)); SUBPS(XMM0, R(fpScratchReg5)); MULPS(fpScratchReg1, R(XMM0)); MULPS(fpScratchReg2, R(fpScratchReg5)); MULPS(fpScratchReg3, R(XMM0)); MULPS(fpScratchReg4, R(fpScratchReg5)); // Now set top=fpScratchReg1, bottom=fpScratchReg3. ADDPS(fpScratchReg1, R(fpScratchReg2)); ADDPS(fpScratchReg3, R(fpScratchReg4)); // Next, time for frac_v. MOVD_xmm(fpScratchReg5, MDisp(RSP, 32)); CVTDQ2PS(fpScratchReg5, R(fpScratchReg5)); SHUFPS(fpScratchReg5, R(fpScratchReg5), _MM_SHUFFLE(0, 0, 0, 0)); MULPS(fpScratchReg5, M(by256)); MOVAPS(XMM0, M(ones)); SUBPS(XMM0, R(fpScratchReg5)); MULPS(fpScratchReg1, R(XMM0)); MULPS(fpScratchReg3, R(fpScratchReg5)); // Still at the 255 scale, now we're interpolated. ADDPS(fpScratchReg1, R(fpScratchReg3)); // Time to convert back to a single 32 bit value. CVTPS2DQ(fpScratchReg1, R(fpScratchReg1)); PACKSSDW(fpScratchReg1, R(fpScratchReg1)); PACKUSWB(fpScratchReg1, R(fpScratchReg1)); MOVD_xmm(R(resultReg), fpScratchReg1); if (id.hasInvalidPtr) { SetJumpTarget(zeroSrc); } ADD(64, R(RSP), Imm8(24)); POP(arg3Reg); POP(arg4Reg); POP(R12); POP(R13); POP(R14); POP(R15); RET(); EndWrite(); return (LinearFunc)start; }