Final ASM cleanups

Source/lighting.cpp

@@ -1555,29 +1555,27 @@ void __cdecl ProcessVisionList()
 
 void __cdecl lighting_color_cycling()
 {
-	char *v0;       // eax
+	int i, j, l;
-	signed int v1;  // ebx
+	BYTE col;
-	char *v2;       // eax
+	BYTE *tbl;
-	char *v3;       // edi
-	char v4;        // dl
-	const void *v5; // esi
 
-	if (leveltype == DTYPE_HELL) {
+	l = light4flag ? 4 : 16;
-		v0 = pLightTbl;
+
-		if ((light4flag != 0 ? 4 : 16) > 0) {
+	if(leveltype != DTYPE_HELL) {
-			v1 = light4flag != 0 ? 4 : 16;
+		return;
-			do {
+	}
-				v2 = v0 + 1;
+
-				v3 = v2;
+	tbl = (BYTE *)pLightTbl;
-				v4 = *v2;
+
-				v5 = v2 + 1;
+	for(j = 0; j < l; j++) {
-				v2 += 30;
+		tbl++;
-				qmemcpy(v3, v5, 0x1Eu);
+		col = *tbl;
-				*v2 = v4;
+		for(i = 0; i < 30; i++) {
-				v0 = v2 + 225;
+			tbl[0] = tbl[1];
-				--v1;
+			tbl++;
-			} while (v1);
 		}
+		*tbl = col;
+		tbl += 225;
 	}
 }
 // 525728: using guessed type int light4flag;

Source/scrollrt.cpp

@@ -2229,12 +2229,33 @@ void __fastcall DrawZoom(int x, int y)
 
 void __cdecl ClearScreenBuffer()
 {
-	int i; // edx
-
 	j_lock_buf_priv(3);
 
-	for (i = 0; i < 480; i++)
+	/// ASSERT: assert(gpBuffer);
-		memset(&gpBuffer[SCREENXY(0, i)], 0, 640);
+
+#if (_MSC_VER >= 800) && (_MSC_VER <= 1200)
+	__asm {
+		mov		edi, gpBuffer
+		add		edi, SCREENXY(0, 0)
+		mov		edx, 480
+		xor		eax, eax
+	zeroline:
+		mov		ecx, 640 / 4
+		rep stosd
+		add		edi, 768 - 640
+		dec		edx
+		jnz		zeroline
+	}
+#else
+	int i;
+	BYTE *dst;
+
+	dst = &gpBuffer[SCREENXY(0, 0)];
+
+	for(i = 0; i < 480; i++, dst += 768) {
+		memset(dst, 0, 640);
+	}
+#endif
 
 	j_unlock_buf_priv(3);
 }
@@ -2608,67 +2629,91 @@ void __cdecl DrawFPS()
 }
 #endif
 
-void __fastcall DoBlitScreen(int dwX, int dwY, int dwWdt, int dwHgt)
+void __fastcall DoBlitScreen(DWORD dwX, DWORD dwY, DWORD dwWdt, DWORD dwHgt)
 {
-	int v4;             // esi
+	int nSrcOff, nDstOff, nSrcWdt, nDstWdt;
-	int v5;             // edi
+	DWORD dwTicks;
-	int v6;             // ecx
+	HRESULT hDDVal;
-	char *v7;           // esi
+	RECT SrcRect;
-	char *v8;           // edi
+
-	int v9;             // edx
+	/// ASSERT: assert(! (dwX & 3));
-	RECT Rect;          // [esp+Ch] [ebp-20h]
+	/// ASSERT: assert(! (dwWdt & 3));
-	int v14;            // [esp+1Ch] [ebp-10h]
+
-	LONG v15;           // [esp+20h] [ebp-Ch]
+	if(lpDDSBackBuf != NULL) {
-	int v16;            // [esp+24h] [ebp-8h]
+		SrcRect.left = dwX + 64;
-	LONG v17;           // [esp+28h] [ebp-4h]
+		SrcRect.top = dwY + 160;
-	HRESULT error_code; // [esp+34h] [ebp+8h]
+		SrcRect.right = SrcRect.left + dwWdt - 1;
-	int error_codea;    // [esp+34h] [ebp+8h]
+		SrcRect.bottom = SrcRect.top + dwHgt - 1;
-	int a4;             // [esp+38h] [ebp+Ch]
+		/// ASSERT: assert(! gpBuffer);
-
+		dwTicks = GetTickCount();
-	v4 = dwY;
+		while(1) {
-	v5 = dwX;
-	if (lpDDSBackBuf != NULL) {
-		Rect.left = dwX + 64;
-		Rect.right = dwX + 64 + dwWdt - 1;
-		Rect.top = dwY + 160;
-		Rect.bottom = dwY + 160 + dwHgt - 1;
-		a4 = GetTickCount();
-		while (1) {
 #ifdef __cplusplus
-			error_code = lpDDSPrimary->BltFast(v5, v4, lpDDSBackBuf, &Rect, DDBLTFAST_WAIT);
+			hDDVal = lpDDSPrimary->BltFast(dwX, dwY, lpDDSBackBuf, &SrcRect, DDBLTFAST_WAIT);
 #else
-			error_code = lpDDSPrimary->lpVtbl->BltFast(lpDDSPrimary, v5, v4, lpDDSBackBuf, &Rect, DDBLTFAST_WAIT);
+			hDDVal = lpDDSPrimary->lpVtbl->BltFast(lpDDSPrimary, dwX, dwY, lpDDSBackBuf, &SrcRect, DDBLTFAST_WAIT);
 #endif
-			if (!error_code)
+			if(hDDVal == DD_OK) {
 				break;
-			if (a4 - GetTickCount() <= 5000) {
-				Sleep(1u);
-				if (error_code == DDERR_SURFACELOST)
-					return;
-				if (error_code == DDERR_WASSTILLDRAWING || error_code == DDERR_SURFACEBUSY)
-					continue;
 			}
-			if (error_code != DDERR_SURFACELOST && error_code != DDERR_WASSTILLDRAWING && error_code != DDERR_SURFACEBUSY)
+			if(dwTicks - GetTickCount() > 5000) {
-				DDErrMsg(error_code, 3596, "C:\\Src\\Diablo\\Source\\SCROLLRT.CPP");
+				break;
-			return;
+			}
+			Sleep(1);
+			if(hDDVal == DDERR_SURFACELOST) {
+				return;
+			}
+			if(hDDVal != DDERR_WASSTILLDRAWING && hDDVal != DDERR_SURFACEBUSY) {
+				break;
+			}
+		}
+		if(hDDVal != DDERR_SURFACELOST
+		&& hDDVal != DDERR_WASSTILLDRAWING
+		&& hDDVal != DDERR_SURFACEBUSY
+		&& hDDVal != DD_OK) {
+			DDErrMsg(hDDVal, 3596, "C:\\Src\\Diablo\\Source\\SCROLLRT.CPP");
 		}
 	} else {
-		v14 = 768 * dwY + dwX + 0x1E040;
+		nSrcOff = SCREENXY(dwX, dwY);
-		v17 = DDS_desc.lPitch - dwWdt;
+		nDstOff = dwX + dwY * DDS_desc.lPitch;
-		v15 = dwX + dwY * DDS_desc.lPitch;
+		nSrcWdt = 768 - dwWdt;
-		v6 = 768 - dwWdt;
+		nDstWdt = DDS_desc.lPitch - dwWdt;
-		error_codea = (unsigned int)dwWdt >> 2;
+		dwWdt >>= 2;
-		v16 = v6;
+
 		j_lock_buf_priv(6);
-		v7 = (char *)gpBuffer + v14;
+
-		v8 = (char *)DDS_desc.lpSurface + v15;
+		/// ASSERT: assert(gpBuffer);
-		v9 = dwHgt;
+
-		do {
+#if (_MSC_VER >= 800) && (_MSC_VER <= 1200)
-			qmemcpy(v8, v7, 4 * error_codea);
+		__asm {
-			v7 += 4 * error_codea + v16;
+			mov		esi, gpBuffer
-			v8 += 4 * error_codea + v17;
+			mov		edi, DDS_desc.lpSurface
-			--v9;
+			add		esi, nSrcOff
-		} while (v9);
+			add		edi, nDstOff
+			mov		eax, nSrcWdt
+			mov		ebx, nDstWdt
+			mov		edx, dwHgt
+		blitline:
+			mov		ecx, dwWdt
+			rep movsd
+			add		esi, eax
+			add		edi, ebx
+			dec		edx
+			jnz		blitline
+		}
+#else
+		int wdt, hgt;
+		BYTE *src, *dst;
+
+		src = &gpBuffer[nSrcOff];
+		dst = (BYTE *)DDS_desc.lpSurface + nDstOff;
+
+		for(hgt = 0; hgt < dwHgt; hgt++, src += nSrcWdt, dst += nDstWdt) {
+			for(wdt = 0; wdt < 4 * dwWdt; wdt++) {
+				*dst++ = *src++;
+			}
+		}
+#endif
+
 		j_unlock_buf_priv(6);
 	}
 }

Source/scrollrt.h

@@ -47,7 +47,7 @@ void __fastcall DrawMain(int dwHgt, int draw_desc, int draw_hp, int draw_mana, i
 #ifdef _DEBUG
 void __cdecl DrawFPS();
 #endif
-void __fastcall DoBlitScreen(int dwX, int dwY, int dwWdt, int dwHgt);
+void __fastcall DoBlitScreen(DWORD dwX, DWORD dwY, DWORD dwWdt, DWORD dwHgt);
 void __cdecl DrawAndBlit();
 
 /* rdata */