; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.40219.01 

	TITLE	E:\Private\Frank\Code\blu-flame.org\4kgfx\mesh.cpp
	.686P
	.XMM
	include listing.inc
	.model	flat

INCLUDELIB MSVCRT
INCLUDELIB OLDNAMES

PUBLIC	?glGenVertexArrays@@3P6GXHPAI@ZA		; glGenVertexArrays
PUBLIC	?glBindVertexArray@@3P6GXI@ZA			; glBindVertexArray
PUBLIC	?glGenBuffers@@3P6GXHPAI@ZA			; glGenBuffers
PUBLIC	?glBindBuffer@@3P6GXII@ZA			; glBindBuffer
PUBLIC	?glBufferData@@3P6GXI_JPBXI@ZA			; glBufferData
PUBLIC	?glGetAttribLocation@@3P6GHIPBD@ZA		; glGetAttribLocation
PUBLIC	?glEnableVertexAttribArray@@3P6GXI@ZA		; glEnableVertexAttribArray
PUBLIC	?glVertexAttribPointer@@3P6GXIHIEHPBX@ZA	; glVertexAttribPointer
PUBLIC	?glMapBuffer@@3P6GPAXII@ZA			; glMapBuffer
PUBLIC	?glUnmapBuffer@@3P6GEI@ZA			; glUnmapBuffer
_BSS	SEGMENT
?glGenVertexArrays@@3P6GXHPAI@ZA DD 01H DUP (?)		; glGenVertexArrays
?glBindVertexArray@@3P6GXI@ZA DD 01H DUP (?)		; glBindVertexArray
?glGenBuffers@@3P6GXHPAI@ZA DD 01H DUP (?)		; glGenBuffers
?glBindBuffer@@3P6GXII@ZA DD 01H DUP (?)		; glBindBuffer
?glBufferData@@3P6GXI_JPBXI@ZA DD 01H DUP (?)		; glBufferData
?glGetAttribLocation@@3P6GHIPBD@ZA DD 01H DUP (?)	; glGetAttribLocation
?glEnableVertexAttribArray@@3P6GXI@ZA DD 01H DUP (?)	; glEnableVertexAttribArray
?glVertexAttribPointer@@3P6GXIHIEHPBX@ZA DD 01H DUP (?)	; glVertexAttribPointer
?glMapBuffer@@3P6GPAXII@ZA DD 01H DUP (?)		; glMapBuffer
?glUnmapBuffer@@3P6GEI@ZA DD 01H DUP (?)		; glUnmapBuffer
_BSS	ENDS
PUBLIC	??0MeshVertex@@QAE@XZ				; MeshVertex::MeshVertex
EXTRN	??0vec4@@QAE@XZ:PROC				; vec4::vec4
; Function compile flags: /Ogspy
;	COMDAT ??0MeshVertex@@QAE@XZ
compile	SEGMENT
??0MeshVertex@@QAE@XZ PROC				; MeshVertex::MeshVertex, COMDAT
; _this$ = ecx
	push	esi
	mov	esi, ecx
	call	??0vec4@@QAE@XZ				; vec4::vec4
	lea	ecx, DWORD PTR [esi+16]
	call	??0vec4@@QAE@XZ				; vec4::vec4
	mov	eax, esi
	pop	esi
	ret	0
??0MeshVertex@@QAE@XZ ENDP				; MeshVertex::MeshVertex
compile	ENDS
PUBLIC	??_H@YGXPAXIHP6EPAX0@Z@Z			; `vector constructor iterator'
; Function compile flags: /Ogspy
;	COMDAT ??_H@YGXPAXIHP6EPAX0@Z@Z
_TEXT	SEGMENT
___t$ = 8						; size = 4
___s$ = 12						; size = 4
___n$ = 16						; size = 4
___f$ = 20						; size = 4
??_H@YGXPAXIHP6EPAX0@Z@Z PROC				; `vector constructor iterator', COMDAT
	push	ebp
	mov	ebp, esp
	dec	DWORD PTR ___n$[ebp]
	js	SHORT $LN1@vector
	push	esi
	mov	esi, DWORD PTR ___t$[ebp]
$LL2@vector:
	mov	ecx, esi
	call	DWORD PTR ___f$[ebp]
	add	esi, DWORD PTR ___s$[ebp]
	dec	DWORD PTR ___n$[ebp]
	jns	SHORT $LL2@vector
	pop	esi
$LN1@vector:
	pop	ebp
	ret	16					; 00000010H
??_H@YGXPAXIHP6EPAX0@Z@Z ENDP				; `vector constructor iterator'
_TEXT	ENDS
PUBLIC	??_C@_08LMCMEEB@inNormal?$AA@			; `string'
PUBLIC	??_C@_0L@LKEIBJK@inPosition?$AA@		; `string'
PUBLIC	?Render@Mesh@@QAEXXZ				; Mesh::Render
EXTRN	__imp__glDrawElements@16:PROC
EXTRN	?currentProgramId@@3IA:DWORD			; currentProgramId
;	COMDAT ??_C@_08LMCMEEB@inNormal?$AA@
; File e:\private\frank\code\blu-flame.org\4kgfx\mesh.cpp
CONST	SEGMENT
??_C@_08LMCMEEB@inNormal?$AA@ DB 'inNormal', 00H	; `string'
CONST	ENDS
;	COMDAT ??_C@_0L@LKEIBJK@inPosition?$AA@
CONST	SEGMENT
??_C@_0L@LKEIBJK@inPosition?$AA@ DB 'inPosition', 00H	; `string'
; Function compile flags: /Ogspy
CONST	ENDS
compile	SEGMENT
?Render@Mesh@@QAEXXZ PROC				; Mesh::Render
; _this$ = ecx

; 24   : {

	push	ebx
	push	ebp
	push	esi
	push	edi
	mov	esi, ecx

; 25   : 	glBindVertexArray(VertexArrayObject);

	push	DWORD PTR [esi+4751408]
	call	DWORD PTR ?glBindVertexArray@@3P6GXI@ZA	; glBindVertexArray

; 26   : 
; 27   : 	unsigned int positionId = glGetAttribLocation(currentProgramId, "inPosition");

	push	OFFSET ??_C@_0L@LKEIBJK@inPosition?$AA@
	push	DWORD PTR ?currentProgramId@@3IA	; currentProgramId
	call	DWORD PTR ?glGetAttribLocation@@3P6GHIPBD@ZA ; glGetAttribLocation

; 28   : 	unsigned int normalId = glGetAttribLocation(currentProgramId, "inNormal");

	push	OFFSET ??_C@_08LMCMEEB@inNormal?$AA@
	push	DWORD PTR ?currentProgramId@@3IA	; currentProgramId
	mov	edi, eax
	call	DWORD PTR ?glGetAttribLocation@@3P6GHIPBD@ZA ; glGetAttribLocation

; 29   : 
; 30   : 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBufferObject);

	push	DWORD PTR [esi+4751416]
	mov	ebp, eax
	push	34963					; 00008893H
	call	DWORD PTR ?glBindBuffer@@3P6GXII@ZA	; glBindBuffer

; 31   : 	glBindBuffer(GL_ARRAY_BUFFER, VertexArrayBuffer);

	push	DWORD PTR [esi+4751412]
	push	34962					; 00008892H
	call	DWORD PTR ?glBindBuffer@@3P6GXII@ZA	; glBindBuffer

; 32   : 
; 33   : 	if (positionId+1 != 0)

	lea	eax, DWORD PTR [edi+1]
	mov	ebx, 5126				; 00001406H
	test	eax, eax
	je	SHORT $LN2@Render

; 34   : 	{
; 35   : 		glEnableVertexAttribArray(positionId);  

	push	edi
	call	DWORD PTR ?glEnableVertexAttribArray@@3P6GXI@ZA ; glEnableVertexAttribArray

; 36   : 		glVertexAttribPointer(positionId, 4, GL_FLOAT, GL_FALSE, sizeof(MeshVertex), (const GLvoid*)0); 

	push	0
	push	32					; 00000020H
	push	0
	push	ebx
	push	4
	push	edi
	call	DWORD PTR ?glVertexAttribPointer@@3P6GXIHIEHPBX@ZA ; glVertexAttribPointer
$LN2@Render:

; 37   : 	}
; 38   : 	if (normalId+1 != 0)

	lea	eax, DWORD PTR [ebp+1]
	test	eax, eax
	je	SHORT $LN5@Render

; 39   : 	{
; 40   : 		glEnableVertexAttribArray(normalId);

	push	ebp
	call	DWORD PTR ?glEnableVertexAttribArray@@3P6GXI@ZA ; glEnableVertexAttribArray

; 41   : 		glVertexAttribPointer(normalId, 4, GL_FLOAT, GL_FALSE, sizeof(MeshVertex), (const GLvoid*)16);

	push	16					; 00000010H
	push	32					; 00000020H
	push	0
	push	ebx
	push	4
	push	ebp
	call	DWORD PTR ?glVertexAttribPointer@@3P6GXIHIEHPBX@ZA ; glVertexAttribPointer
$LN5@Render:

; 42   : 	}
; 43   : 
; 44   : 	glDrawElements(GL_TRIANGLES, IndexCount, GL_UNSIGNED_SHORT, 0);

	push	0
	push	5123					; 00001403H
	push	DWORD PTR [esi+4]
	push	4
	call	DWORD PTR __imp__glDrawElements@16

; 45   : 
; 46   : 	glBindVertexArray(0);

	push	0
	call	DWORD PTR ?glBindVertexArray@@3P6GXI@ZA	; glBindVertexArray
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 47   : }

	ret	0
?Render@Mesh@@QAEXXZ ENDP				; Mesh::Render
compile	ENDS
PUBLIC	?Lock@Mesh@@QAEXXZ				; Mesh::Lock
; Function compile flags: /Ogspy
compile	SEGMENT
?Lock@Mesh@@QAEXXZ PROC					; Mesh::Lock
; _this$ = ecx

; 51   : {

	push	ebx
	push	ebp
	push	esi
	push	edi
	mov	esi, ecx

; 52   : 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBufferObject);

	push	DWORD PTR [esi+4751416]
	mov	ebp, 34963				; 00008893H
	push	ebp
	call	DWORD PTR ?glBindBuffer@@3P6GXII@ZA	; glBindBuffer

; 53   : 	glBindBuffer(GL_ARRAY_BUFFER, VertexArrayBuffer);

	push	DWORD PTR [esi+4751412]
	lea	ebx, DWORD PTR [ebp-1]
	push	ebx
	call	DWORD PTR ?glBindBuffer@@3P6GXII@ZA	; glBindBuffer

; 54   : 
; 55   : 	IndexBuffer = (unsigned short*)glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_WRITE);

	lea	edi, DWORD PTR [ebp+39]
	push	edi
	push	ebp
	call	DWORD PTR ?glMapBuffer@@3P6GPAXII@ZA	; glMapBuffer

; 56   : 	VertexBuffer = (MeshVertex*)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);

	push	edi
	push	ebx
	mov	DWORD PTR [esi+16], eax
	call	DWORD PTR ?glMapBuffer@@3P6GPAXII@ZA	; glMapBuffer
	pop	edi
	mov	DWORD PTR [esi+12], eax
	pop	esi
	pop	ebp
	pop	ebx

; 57   : }

	ret	0
?Lock@Mesh@@QAEXXZ ENDP					; Mesh::Lock
compile	ENDS
PUBLIC	?Unlock@Mesh@@QAEXXZ				; Mesh::Unlock
; Function compile flags: /Ogspy
compile	SEGMENT
?Unlock@Mesh@@QAEXXZ PROC				; Mesh::Unlock
; _this$ = ecx

; 62   : 	glUnmapBuffer(GL_ARRAY_BUFFER);

	push	34962					; 00008892H
	call	DWORD PTR ?glUnmapBuffer@@3P6GEI@ZA	; glUnmapBuffer

; 63   : 	glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);

	push	34963					; 00008893H
	call	DWORD PTR ?glUnmapBuffer@@3P6GEI@ZA	; glUnmapBuffer

; 64   : }

	ret	0
?Unlock@Mesh@@QAEXXZ ENDP				; Mesh::Unlock
compile	ENDS
PUBLIC	__real@00000000
PUBLIC	__real@3f800000
PUBLIC	?GenerateNormals@Mesh@@AAEXXZ			; Mesh::GenerateNormals
EXTRN	??Yvec4@@QAEXABU0@@Z:PROC			; vec4::operator+=
EXTRN	?cross@@YA?AUvec4@@AAU1@0@Z:PROC		; cross
EXTRN	??Gvec4@@QBE?AU0@ABU0@@Z:PROC			; vec4::operator-
EXTRN	??0vec4@@QAE@MMMM@Z:PROC			; vec4::vec4
EXTRN	__fltused:DWORD
;	COMDAT __real@00000000
CONST	SEGMENT
__real@00000000 DD 000000000r			; 0
CONST	ENDS
;	COMDAT __real@3f800000
CONST	SEGMENT
__real@3f800000 DD 03f800000r			; 1
; Function compile flags: /Ogspy
CONST	ENDS
compile	SEGMENT
tv340 = -80						; size = 4
tv327 = -80						; size = 4
tv432 = -76						; size = 4
_i$17804 = -76						; size = 4
tv390 = -72						; size = 4
_count$17813 = -68					; size = 4
_i$17809 = -64						; size = 4
tv86 = -60						; size = 4
_index$17818 = -56					; size = 4
_indexNext$17820 = -52					; size = 4
_p2$17824 = -48						; size = 16
_p1$17822 = -32						; size = 16
$T17808 = -32						; size = 16
$T17825 = -16						; size = 16
?GenerateNormals@Mesh@@AAEXXZ PROC			; Mesh::GenerateNormals
; _this$ = ecx

; 68   : {

	push	ebp
	mov	ebp, esp
	and	esp, -16				; fffffff0H
	sub	esp, 84					; 00000054H
	push	ebx

; 69   : 	for (int i = 0; i < VertexCount; ++i)

	xor	eax, eax
	mov	ebx, ecx
	push	esi
	push	edi
	mov	DWORD PTR _i$17804[esp+96], eax
	cmp	DWORD PTR [ebx], eax
	jle	SHORT $LN6@GenerateNo
	mov	DWORD PTR tv327[esp+96], eax
$LN8@GenerateNo:

; 70   : 	{
; 71   : 		VertexBuffer[i].Normal = vec4(0, 0, 0, 1);

	fld1
	sub	esp, 16					; 00000010H
	fstp	DWORD PTR [esp+12]
	lea	ecx, DWORD PTR $T17808[esp+112]
	fldz
	fst	DWORD PTR [esp+8]
	fst	DWORD PTR [esp+4]
	fstp	DWORD PTR [esp]
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4
	mov	ecx, DWORD PTR [ebx+12]
	mov	edx, DWORD PTR tv327[esp+96]
	inc	DWORD PTR _i$17804[esp+96]
	add	DWORD PTR tv327[esp+96], 32		; 00000020H
	mov	esi, eax
	mov	eax, DWORD PTR _i$17804[esp+96]
	lea	edi, DWORD PTR [ecx+edx+16]
	movsd
	movsd
	movsd
	movsd
	cmp	eax, DWORD PTR [ebx]
	jl	SHORT $LN8@GenerateNo
$LN6@GenerateNo:

; 72   : 	}
; 73   : 
; 74   : 	for (int i = 0; i < IndexCount; )

	xor	esi, esi
	cmp	DWORD PTR [ebx+4], esi
	jle	$LN4@GenerateNo
$LN5@GenerateNo:

; 75   : 	{
; 76   : 		int count = IndexBuffer[i];

	mov	eax, DWORD PTR [ebx+16]
	movzx	edi, WORD PTR [eax+esi*2]

; 77   : 		++i;

	inc	esi
	mov	DWORD PTR _count$17813[esp+96], edi
	mov	DWORD PTR _i$17809[esp+96], esi

; 78   : 		for (int j = 0; j < count; ++j)

	test	edi, edi
	jle	$LN1@GenerateNo

; 75   : 	{
; 76   : 		int count = IndexBuffer[i];

	lea	eax, DWORD PTR [edi-1]
	mov	DWORD PTR tv340[esp+96], eax
	lea	eax, DWORD PTR [esi+esi]

; 78   : 		for (int j = 0; j < count; ++j)

	mov	DWORD PTR tv432[esp+96], 2
	sub	DWORD PTR tv432[esp+96], edi
	mov	DWORD PTR tv390[esp+96], eax
	mov	DWORD PTR tv86[esp+96], edi
$LL18@GenerateNo:

; 79   : 		{
; 80   : 			int index = IndexBuffer[i + j];

	mov	ecx, DWORD PTR [ebx+16]
	mov	eax, DWORD PTR tv390[esp+96]
	movzx	eax, WORD PTR [eax+ecx]
	mov	DWORD PTR _index$17818[esp+96], eax

; 81   : 			int indexPrev = IndexBuffer[i + ((j + count - 1) % count)];
; 82   : 			int indexNext = IndexBuffer[i + ((j + 1) % count)];

	mov	eax, DWORD PTR tv432[esp+96]
	add	eax, DWORD PTR tv340[esp+96]
	cdq
	idiv	edi

; 83   : 			vec4 p1(VertexBuffer[indexPrev].Position - VertexBuffer[index].Position);

	mov	edi, DWORD PTR [ebx+12]
	add	edx, esi
	movzx	eax, WORD PTR [ecx+edx*2]
	mov	esi, DWORD PTR _index$17818[esp+96]
	mov	DWORD PTR _indexNext$17820[esp+96], eax
	shl	esi, 5
	lea	eax, DWORD PTR [esi+edi]
	push	eax
	lea	eax, DWORD PTR _p1$17822[esp+100]
	push	eax
	mov	eax, DWORD PTR tv340[esp+104]
	cdq
	idiv	DWORD PTR _count$17813[esp+104]
	add	edx, DWORD PTR _i$17809[esp+104]
	movzx	ecx, WORD PTR [ecx+edx*2]
	shl	ecx, 5
	add	ecx, edi
	call	??Gvec4@@QBE?AU0@ABU0@@Z		; vec4::operator-

; 84   : 			vec4 p2(VertexBuffer[indexNext].Position - VertexBuffer[index].Position);

	mov	eax, DWORD PTR [ebx+12]
	lea	ecx, DWORD PTR [eax+esi]
	push	ecx
	lea	ecx, DWORD PTR _p2$17824[esp+100]
	push	ecx
	mov	ecx, DWORD PTR _indexNext$17820[esp+104]
	shl	ecx, 5
	add	ecx, eax
	call	??Gvec4@@QBE?AU0@ABU0@@Z		; vec4::operator-

; 85   : 			VertexBuffer[index].Normal += cross(p1, p2);

	lea	eax, DWORD PTR _p2$17824[esp+96]
	push	eax
	lea	eax, DWORD PTR _p1$17822[esp+100]
	push	eax
	lea	eax, DWORD PTR $T17825[esp+104]
	push	eax
	call	?cross@@YA?AUvec4@@AAU1@0@Z		; cross
	add	esp, 12					; 0000000cH
	push	eax
	mov	eax, DWORD PTR [ebx+12]
	lea	ecx, DWORD PTR [eax+esi+16]
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=
	add	DWORD PTR tv390[esp+96], 2
	inc	DWORD PTR tv340[esp+96]
	dec	DWORD PTR tv86[esp+96]
	mov	edi, DWORD PTR _count$17813[esp+96]
	mov	esi, DWORD PTR _i$17809[esp+96]
	jne	$LL18@GenerateNo
$LN1@GenerateNo:

; 86   : 		}
; 87   : 		i += count;

	add	esi, edi
	cmp	esi, DWORD PTR [ebx+4]
	jl	$LN5@GenerateNo
$LN4@GenerateNo:

; 88   : 	}
; 89   : }

	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	0
?GenerateNormals@Mesh@@AAEXXZ ENDP			; Mesh::GenerateNormals
compile	ENDS
PUBLIC	?NormalizeNormals@Mesh@@AAEXXZ			; Mesh::NormalizeNormals
EXTRN	?normalize@@YA?AUvec4@@ABU1@@Z:PROC		; normalize
; Function compile flags: /Ogspy
compile	SEGMENT
tv151 = -24						; size = 4
_i$17829 = -20						; size = 4
$T17833 = -16						; size = 16
?NormalizeNormals@Mesh@@AAEXXZ PROC			; Mesh::NormalizeNormals
; _this$ = ecx

; 93   : {

	push	ebp
	mov	ebp, esp
	and	esp, -16				; fffffff0H
	sub	esp, 36					; 00000024H
	push	ebx
	push	esi
	push	edi

; 94   : 	for (int i = 0; i < VertexCount; ++i)

	xor	edi, edi
	mov	ebx, ecx
	mov	DWORD PTR _i$17829[esp+48], edi
	cmp	DWORD PTR [ebx], edi
	jle	SHORT $LN1@NormalizeN
	mov	DWORD PTR tv151[esp+48], edi
	jmp	SHORT $LN3@NormalizeN
$LL8@NormalizeN:
	mov	edi, DWORD PTR tv151[esp+48]
$LN3@NormalizeN:

; 95   : 	{
; 96   : 		VertexBuffer[i].Normal = normalize(VertexBuffer[i].Normal);

	mov	eax, DWORD PTR [ebx+12]
	lea	eax, DWORD PTR [edi+eax+16]
	push	eax
	lea	eax, DWORD PTR $T17833[esp+52]
	push	eax
	call	?normalize@@YA?AUvec4@@ABU1@@Z		; normalize
	inc	DWORD PTR _i$17829[esp+56]
	add	DWORD PTR tv151[esp+56], 32		; 00000020H
	pop	ecx
	pop	ecx
	mov	ecx, DWORD PTR [ebx+12]
	lea	edi, DWORD PTR [edi+ecx+16]
	mov	esi, eax
	mov	eax, DWORD PTR _i$17829[esp+48]
	movsd
	movsd
	movsd
	movsd
	cmp	eax, DWORD PTR [ebx]
	jl	SHORT $LL8@NormalizeN
$LN1@NormalizeN:

; 97   : 	}
; 98   : }

	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	0
?NormalizeNormals@Mesh@@AAEXXZ ENDP			; Mesh::NormalizeNormals
compile	ENDS
PUBLIC	?Reset@OpInfo@Mesh@@QAEXXZ			; Mesh::OpInfo::Reset
EXTRN	_memclear:PROC
; Function compile flags: /Ogspy
compile	SEGMENT
?Reset@OpInfo@Mesh@@QAEXXZ PROC				; Mesh::OpInfo::Reset
; _this$ = ecx

; 308  : {

	push	esi
	push	edi
	mov	esi, ecx

; 309  : 	memclear(NextVB, sizeof (NextVB));

	push	2097152					; 00200000H
	push	esi
	call	_memclear

; 310  : 	memclear(NextIB, sizeof (NextIB));

	mov	edi, 589824				; 00090000H
	lea	eax, DWORD PTR [esi+2097152]
	push	edi
	push	eax
	call	_memclear

; 311  : 	memclear(EdgeConfiguration, sizeof (EdgeConfiguration));

	lea	eax, DWORD PTR [esi+2686992]
	push	1179648					; 00120000H
	push	eax
	call	_memclear

; 312  : 	memclear(EdgeUsage, sizeof (EdgeUsage));

	lea	eax, DWORD PTR [esi+3866640]
	push	294912					; 00048000H
	push	eax
	call	_memclear

; 313  : 	memclear(EdgeID, sizeof (EdgeID));

	lea	eax, DWORD PTR [esi+4161552]
	push	edi
	push	eax
	call	_memclear

; 314  : 
; 315  : 	NextVertexCount = 0;

	xor	eax, eax
	add	esp, 40					; 00000028H
	pop	edi
	mov	DWORD PTR [esi+2686976], eax

; 316  : 	NextIndexCount = 0;

	mov	DWORD PTR [esi+2686980], eax

; 317  : 	NextFaceCount = 0;

	mov	DWORD PTR [esi+2686984], eax

; 318  : 
; 319  : 	EdgeCount = 0;

	mov	DWORD PTR [esi+2686988], eax
	pop	esi

; 320  : }

	ret	0
?Reset@OpInfo@Mesh@@QAEXXZ ENDP				; Mesh::OpInfo::Reset
compile	ENDS
PUBLIC	?MakeEdgeID@OpInfo@Mesh@@QAEHGG@Z		; Mesh::OpInfo::MakeEdgeID
; Function compile flags: /Ogspy
compile	SEGMENT
_VertexA$ = 8						; size = 2
_VertexB$ = 12						; size = 2
?MakeEdgeID@OpInfo@Mesh@@QAEHGG@Z PROC			; Mesh::OpInfo::MakeEdgeID
; _this$ = ecx

; 325  : 	unsigned int edgeConfiguration = VertexA > VertexB ? (VertexA << 16 | VertexB) : (VertexB << 16 | VertexA);

	mov	ax, WORD PTR _VertexA$[esp-4]
	cmp	ax, WORD PTR _VertexB$[esp-4]
	jbe	SHORT $LN7@MakeEdgeID
	movzx	edx, ax
	movzx	eax, WORD PTR _VertexB$[esp-4]
	jmp	SHORT $LN12@MakeEdgeID
$LN7@MakeEdgeID:
	movzx	edx, WORD PTR _VertexB$[esp-4]
	movzx	eax, ax
$LN12@MakeEdgeID:
	shl	edx, 16					; 00000010H
	push	esi

; 326  : 
; 327  : 	for (int i = 0; i < EdgeCount; ++i)

	mov	esi, DWORD PTR [ecx+2686988]
	or	edx, eax
	xor	eax, eax
	push	edi
	test	esi, esi
	jle	SHORT $LN2@MakeEdgeID
	lea	edi, DWORD PTR [ecx+2686992]
$LL4@MakeEdgeID:

; 328  : 	{
; 329  : 		if (EdgeConfiguration[i] == edgeConfiguration)

	cmp	DWORD PTR [edi], edx
	je	SHORT $LN10@MakeEdgeID

; 326  : 
; 327  : 	for (int i = 0; i < EdgeCount; ++i)

	inc	eax
	add	edi, 4
	cmp	eax, esi
	jl	SHORT $LL4@MakeEdgeID
$LN2@MakeEdgeID:

; 333  : 		}
; 334  : 	}
; 335  : 
; 336  : 	EdgeConfiguration[EdgeCount] = edgeConfiguration;

	mov	DWORD PTR [ecx+esi*4+2686992], edx

; 337  : 	EdgeUsage[EdgeCount]++;

	mov	eax, DWORD PTR [ecx+2686988]
	lea	eax, DWORD PTR [eax+ecx+3866640]
	inc	BYTE PTR [eax]

; 338  : 	EdgeID[EdgeCount] = NextVertexCount;

	mov	edx, DWORD PTR [ecx+2686988]
	mov	si, WORD PTR [ecx+2686976]
	mov	WORD PTR [ecx+edx*2+4161552], si

; 339  : 	NextVertexCount++;
; 340  : 
; 341  : 	return EdgeCount++;

	mov	eax, DWORD PTR [ecx+2686988]
	inc	DWORD PTR [ecx+2686976]
	lea	edx, DWORD PTR [eax+1]
	mov	DWORD PTR [ecx+2686988], edx
$LN5@MakeEdgeID:

; 342  : }

	pop	edi
	pop	esi
	ret	8
$LN10@MakeEdgeID:

; 330  : 		{
; 331  : 			EdgeUsage[i]++;

	lea	ecx, DWORD PTR [eax+ecx+3866640]
	inc	BYTE PTR [ecx]

; 332  : 			return i;

	jmp	SHORT $LN5@MakeEdgeID
?MakeEdgeID@OpInfo@Mesh@@QAEHGG@Z ENDP			; Mesh::OpInfo::MakeEdgeID
compile	ENDS
PUBLIC	__real@40000000
PUBLIC	?StandardSubdivide@Mesh@@AAEXXZ			; Mesh::StandardSubdivide
EXTRN	??Kvec4@@QBE?AU0@M@Z:PROC			; vec4::operator/
EXTRN	??Hvec4@@QBE?AU0@ABU0@@Z:PROC			; vec4::operator+
EXTRN	_memcpy:PROC
;	COMDAT __real@40000000
CONST	SEGMENT
__real@40000000 DD 040000000r			; 2
; Function compile flags: /Ogspy
CONST	ENDS
compile	SEGMENT
tv601 = -108						; size = 4
_count$17994 = -108					; size = 4
tv569 = -104						; size = 4
_i$17990 = -104						; size = 4
_ibIndex$ = -100					; size = 4
_count$17973 = -100					; size = 4
_nextIndex$17981 = -96					; size = 4
_face$ = -96						; size = 4
tv748 = -92						; size = 4
_prevIndex$17978 = -92					; size = 4
tv246 = -88						; size = 4
tv204 = -84						; size = 4
_i$17969 = -84						; size = 4
tv410 = -80						; size = 4
_nextEdgeID$17983 = -76					; size = 4
tv739 = -72						; size = 4
_prevEdgeID$17982 = -72					; size = 4
_vbFaceOffset$ = -68					; size = 4
_index$17980 = -68					; size = 4
_fp$17995 = -64						; size = 16
$T17985 = -64						; size = 16
$T17984 = -48						; size = 16
$T17987 = -32						; size = 16
$T18001 = -16						; size = 16
$T17986 = -16						; size = 16
?StandardSubdivide@Mesh@@AAEXXZ PROC			; Mesh::StandardSubdivide
; _this$ = ecx

; 346  : {

	push	ebp
	mov	ebp, esp
	and	esp, -16				; fffffff0H
	sub	esp, 116				; 00000074H
	push	ebx
	mov	ebx, ecx
	push	esi

; 347  : 	OP.Reset();

	lea	esi, DWORD PTR [ebx+32]
	push	edi
	mov	ecx, esi
	call	?Reset@OpInfo@Mesh@@QAEXXZ		; Mesh::OpInfo::Reset

; 348  : 	memcpy(OP.NextVB, VertexBuffer, VertexCount * sizeof(MeshVertex));

	mov	eax, DWORD PTR [ebx]
	shl	eax, 5
	push	eax
	push	DWORD PTR [ebx+12]
	push	esi
	call	_memcpy

; 349  : 	OP.NextVertexCount = VertexCount;

	mov	eax, DWORD PTR [ebx]

; 350  : 
; 351  : 	int face = 0;
; 352  : 	for (int i = 0; i < IndexCount; ++face)

	xor	edi, edi
	add	esp, 12					; 0000000cH
	mov	DWORD PTR [ebx+2687008], eax
	cmp	DWORD PTR [ebx+4], edi
	jle	$LN11@StandardSu
$LN13@StandardSu:

; 353  : 	{
; 354  : 		int count = IndexBuffer[i++];

	mov	eax, DWORD PTR [ebx+16]
	movzx	ecx, WORD PTR [eax+edi*2]
	inc	edi
	mov	DWORD PTR _count$17973[esp+128], ecx
	mov	DWORD PTR _i$17969[esp+128], edi

; 355  : 
; 356  : 		for (int j = 0; j < count; ++j)

	test	ecx, ecx
	jle	$LN8@StandardSu

; 353  : 	{
; 354  : 		int count = IndexBuffer[i++];

	or	eax, -1
	lea	edx, DWORD PTR [edi+edi]
	mov	DWORD PTR tv569[esp+128], eax
	mov	DWORD PTR tv601[esp+128], edx
	mov	DWORD PTR tv246[esp+128], ecx
	jmp	SHORT $LN10@StandardSu
$LL24@StandardSu:
	mov	eax, DWORD PTR tv569[esp+128]
$LN10@StandardSu:

; 357  : 		{
; 358  : 			int prevIndex = j - 1;

	mov	edx, eax

; 359  : 			if (prevIndex < 0)

	test	eax, eax
	jns	SHORT $LN7@StandardSu

; 360  : 				prevIndex += count;

	lea	edx, DWORD PTR [eax+ecx]
$LN7@StandardSu:

; 361  : 			prevIndex = IndexBuffer[i + prevIndex];

	mov	ecx, DWORD PTR [ebx+16]
	add	edx, edi
	movzx	edx, WORD PTR [ecx+edx*2]
	mov	DWORD PTR _prevIndex$17978[esp+128], edx

; 362  : 			int index = IndexBuffer[i + j];

	mov	edx, DWORD PTR tv601[esp+128]
	movzx	esi, WORD PTR [edx+ecx]

; 363  : 			int nextIndex = IndexBuffer[i + ((j + 1) % count)];

	add	eax, 2
	cdq
	idiv	DWORD PTR _count$17973[esp+128]

; 364  : 			int prevEdgeID = OP.EdgeID[OP.MakeEdgeID(prevIndex, index)];

	push	esi
	push	DWORD PTR _prevIndex$17978[esp+132]
	mov	DWORD PTR _index$17980[esp+136], esi
	add	edx, edi
	movzx	eax, WORD PTR [ecx+edx*2]
	lea	ecx, DWORD PTR [ebx+32]
	mov	DWORD PTR _nextIndex$17981[esp+136], eax
	call	?MakeEdgeID@OpInfo@Mesh@@QAEHGG@Z	; Mesh::OpInfo::MakeEdgeID
	movzx	edi, WORD PTR [ebx+eax*2+4161584]

; 365  : 			int nextEdgeID = OP.EdgeID[OP.MakeEdgeID(index, nextIndex)];

	push	DWORD PTR _nextIndex$17981[esp+128]
	lea	ecx, DWORD PTR [ebx+32]
	push	esi
	mov	DWORD PTR _prevEdgeID$17982[esp+136], edi
	call	?MakeEdgeID@OpInfo@Mesh@@QAEHGG@Z	; Mesh::OpInfo::MakeEdgeID
	movzx	eax, WORD PTR [ebx+eax*2+4161584]

; 366  : 			OP.NextVB[prevEdgeID].Position = (VertexBuffer[prevIndex].Position + VertexBuffer[index].Position) / 2;

	fld	DWORD PTR __real@40000000
	push	ecx
	mov	DWORD PTR _nextEdgeID$17983[esp+132], eax
	mov	eax, DWORD PTR [ebx+12]
	fstp	DWORD PTR [esp]
	shl	esi, 5
	lea	ecx, DWORD PTR $T17985[esp+132]
	push	ecx
	mov	DWORD PTR tv410[esp+136], esi
	add	esi, eax
	push	esi
	lea	ecx, DWORD PTR $T17984[esp+140]
	push	ecx
	mov	ecx, DWORD PTR _prevIndex$17978[esp+144]
	shl	ecx, 5
	add	ecx, eax
	call	??Hvec4@@QBE?AU0@ABU0@@Z		; vec4::operator+
	mov	ecx, eax
	call	??Kvec4@@QBE?AU0@M@Z			; vec4::operator/

; 367  : 			OP.NextVB[nextEdgeID].Position = (VertexBuffer[nextIndex].Position + VertexBuffer[index].Position) / 2;

	fld	DWORD PTR __real@40000000
	inc	edi
	shl	edi, 5
	add	edi, ebx
	mov	esi, eax
	movsd
	push	ecx
	movsd
	fstp	DWORD PTR [esp]
	movsd
	lea	ecx, DWORD PTR $T17987[esp+132]
	push	ecx
	mov	ecx, DWORD PTR tv410[esp+136]
	movsd
	mov	eax, DWORD PTR [ebx+12]
	add	ecx, eax
	push	ecx
	lea	ecx, DWORD PTR $T17986[esp+140]
	push	ecx
	mov	ecx, DWORD PTR _nextIndex$17981[esp+144]
	shl	ecx, 5
	add	ecx, eax
	call	??Hvec4@@QBE?AU0@ABU0@@Z		; vec4::operator+
	mov	ecx, eax
	call	??Kvec4@@QBE?AU0@M@Z			; vec4::operator/
	mov	ecx, DWORD PTR _nextEdgeID$17983[esp+128]
	lea	edi, DWORD PTR [ecx+1]
	shl	edi, 5
	add	edi, ebx
	mov	esi, eax
	movsd
	movsd
	movsd
	movsd

; 368  : 			OP.NextIB[OP.NextIndexCount + 0] = 4;

	mov	eax, DWORD PTR [ebx+2687012]
	push	4
	pop	edx
	mov	WORD PTR [ebx+eax*2+2097184], dx

; 369  : 			OP.NextIB[OP.NextIndexCount + 1] = 0; // will be set later (face offset)

	mov	eax, DWORD PTR [ebx+2687012]
	add	DWORD PTR tv601[esp+128], 2
	mov	edi, DWORD PTR _i$17969[esp+128]
	xor	edx, edx
	mov	WORD PTR [ebx+eax*2+2097186], dx

; 370  : 			OP.NextIB[OP.NextIndexCount + 2] = prevEdgeID;

	mov	eax, DWORD PTR [ebx+2687012]
	mov	dx, WORD PTR _prevEdgeID$17982[esp+128]
	mov	WORD PTR [ebx+eax*2+2097188], dx

; 371  : 			OP.NextIB[OP.NextIndexCount + 3] = index;

	mov	eax, DWORD PTR [ebx+2687012]
	mov	dx, WORD PTR _index$17980[esp+128]
	mov	WORD PTR [ebx+eax*2+2097190], dx

; 372  : 			OP.NextIB[OP.NextIndexCount + 4] = nextEdgeID;

	mov	eax, DWORD PTR [ebx+2687012]
	mov	WORD PTR [ebx+eax*2+2097192], cx

; 373  : 			OP.NextIndexCount += 5;

	add	DWORD PTR [ebx+2687012], 5

; 374  : 			++OP.NextFaceCount;

	inc	DWORD PTR [ebx+2687016]
	inc	DWORD PTR tv569[esp+128]
	dec	DWORD PTR tv246[esp+128]
	mov	ecx, DWORD PTR _count$17973[esp+128]
	jne	$LL24@StandardSu
$LN8@StandardSu:

; 375  : 		}
; 376  : 
; 377  : 		i += count;

	add	edi, ecx
	cmp	edi, DWORD PTR [ebx+4]
	jl	$LN13@StandardSu
$LN11@StandardSu:

; 378  : 	}
; 379  : 
; 380  : 	int vbFaceOffset = OP.NextVertexCount;

	mov	esi, DWORD PTR [ebx+2687008]

; 381  : 	int ibIndex = 1;
; 382  : 	face = 0;

	xor	edi, edi
	mov	DWORD PTR _vbFaceOffset$[esp+128], esi
	mov	DWORD PTR _ibIndex$[esp+128], 1
	mov	DWORD PTR _face$[esp+128], edi

; 383  : 	for (int i = 0; i < IndexCount; ++face)

	cmp	DWORD PTR [ebx+4], edi
	jle	$LN4@StandardSu

; 378  : 	}
; 379  : 
; 380  : 	int vbFaceOffset = OP.NextVertexCount;

	lea	eax, DWORD PTR [esi+1]
	shl	eax, 5
	add	eax, ebx
	mov	DWORD PTR tv748[esp+128], eax
	jmp	SHORT $LN6@StandardSu
$LL25@StandardSu:
	mov	edi, DWORD PTR _i$17990[esp+128]
	mov	esi, DWORD PTR _vbFaceOffset$[esp+128]
$LN6@StandardSu:

; 384  : 	{
; 385  : 		int count = IndexBuffer[i++];

	mov	eax, DWORD PTR [ebx+16]
	movzx	eax, WORD PTR [eax+edi*2]
	inc	edi

; 386  : 
; 387  : 		vec4 fp;

	lea	ecx, DWORD PTR _fp$17995[esp+128]
	mov	DWORD PTR _count$17994[esp+128], eax
	mov	DWORD PTR _i$17990[esp+128], edi
	call	??0vec4@@QAE@XZ				; vec4::vec4

; 388  : 		for (int j = 0; j < count; ++j)

	cmp	DWORD PTR _count$17994[esp+128], 0
	jle	SHORT $LN1@StandardSu
	mov	eax, DWORD PTR _face$[esp+128]
	add	eax, esi
	mov	DWORD PTR tv739[esp+128], eax
	mov	eax, DWORD PTR _ibIndex$[esp+128]
	lea	esi, DWORD PTR [ebx+eax*2+2097184]
	mov	eax, DWORD PTR _count$17994[esp+128]
	mov	DWORD PTR tv204[esp+128], eax
	imul	eax, 5
	add	edi, edi
	add	DWORD PTR _ibIndex$[esp+128], eax
$LL3@StandardSu:

; 389  : 		{
; 390  : 			fp += VertexBuffer[IndexBuffer[i + j]].Position;

	mov	eax, DWORD PTR [ebx+16]
	movzx	eax, WORD PTR [edi+eax]
	shl	eax, 5
	add	eax, DWORD PTR [ebx+12]
	lea	ecx, DWORD PTR _fp$17995[esp+128]
	push	eax
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=

; 391  : 			OP.NextIB[ibIndex] = vbFaceOffset + face;

	mov	ax, WORD PTR tv739[esp+128]
	mov	WORD PTR [esi], ax

; 392  : 			ibIndex += 5;

	add	esi, 10					; 0000000aH
	add	edi, 2
	dec	DWORD PTR tv204[esp+128]
	jne	SHORT $LL3@StandardSu
$LN1@StandardSu:

; 393  : 		}
; 394  : 		OP.NextVB[vbFaceOffset + face].Position = fp / (float)count;

	fild	DWORD PTR _count$17994[esp+128]
	push	ecx
	lea	eax, DWORD PTR $T18001[esp+132]
	lea	ecx, DWORD PTR _fp$17995[esp+132]
	fstp	DWORD PTR [esp]
	push	eax
	call	??Kvec4@@QBE?AU0@M@Z			; vec4::operator/
	mov	edi, DWORD PTR tv748[esp+128]
	add	DWORD PTR tv748[esp+128], 32		; 00000020H
	mov	esi, eax

; 395  : 		++OP.NextVertexCount;
; 396  : 		i += count;

	mov	eax, DWORD PTR _i$17990[esp+128]
	add	eax, DWORD PTR _count$17994[esp+128]
	movsd
	movsd
	movsd
	movsd
	inc	DWORD PTR [ebx+2687008]
	inc	DWORD PTR _face$[esp+128]
	mov	DWORD PTR _i$17990[esp+128], eax
	cmp	eax, DWORD PTR [ebx+4]
	jl	$LL25@StandardSu
$LN4@StandardSu:

; 397  : 	}
; 398  : 
; 399  : 	memcpy(VertexBuffer, OP.NextVB, MaxVertexBuffer * sizeof(MeshVertex));

	push	2097152					; 00200000H
	lea	eax, DWORD PTR [ebx+32]
	push	eax
	push	DWORD PTR [ebx+12]
	call	_memcpy

; 400  : 	memcpy(IndexBuffer, OP.NextIB, MaxIndexBuffer * sizeof(unsigned short));

	push	589824					; 00090000H
	lea	eax, DWORD PTR [ebx+2097184]
	push	eax
	push	DWORD PTR [ebx+16]
	call	_memcpy

; 401  : 	VertexCount = OP.NextVertexCount;

	mov	eax, DWORD PTR [ebx+2687008]
	mov	DWORD PTR [ebx], eax

; 402  : 	IndexCount = OP.NextIndexCount;

	mov	eax, DWORD PTR [ebx+2687012]
	add	esp, 24					; 00000018H
	mov	DWORD PTR [ebx+4], eax

; 403  : 	FaceCount = OP.NextFaceCount;

	mov	eax, DWORD PTR [ebx+2687016]

; 404  : }

	pop	edi
	pop	esi
	mov	DWORD PTR [ebx+8], eax
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	0
?StandardSubdivide@Mesh@@AAEXXZ ENDP			; Mesh::StandardSubdivide
compile	ENDS
PUBLIC	?Homogenize@Mesh@@AAEXXZ			; Mesh::Homogenize
; Function compile flags: /Ogspy
compile	SEGMENT
?Homogenize@Mesh@@AAEXXZ PROC				; Mesh::Homogenize
; _this$ = ecx

; 457  : 	for (int i = 0; i < VertexCount; ++i)

	xor	edx, edx
	xor	eax, eax
	cmp	DWORD PTR [ecx], edx
	jle	SHORT $LN1@Homogenize
	push	esi
$LL3@Homogenize:

; 458  : 		VertexBuffer[i].Position.w = 1;

	fld1
	mov	esi, DWORD PTR [ecx+12]
	fstp	DWORD PTR [edx+esi+12]
	inc	eax
	add	edx, 32					; 00000020H
	cmp	eax, DWORD PTR [ecx]
	jl	SHORT $LL3@Homogenize
	pop	esi
$LN1@Homogenize:

; 459  : }

	ret	0
?Homogenize@Mesh@@AAEXXZ ENDP				; Mesh::Homogenize
compile	ENDS
PUBLIC	?Transform@Mesh@@QAEXABUMatrix@@@Z		; Mesh::Transform
EXTRN	??DMatrix@@QBE?AUvec4@@ABU1@@Z:PROC		; Matrix::operator*
; Function compile flags: /Ogspy
compile	SEGMENT
tv150 = -24						; size = 4
_i$18034 = -20						; size = 4
$T18038 = -16						; size = 16
_transform$ = 8						; size = 4
?Transform@Mesh@@QAEXABUMatrix@@@Z PROC			; Mesh::Transform
; _this$ = ecx

; 463  : {

	push	ebp
	mov	ebp, esp
	and	esp, -16				; fffffff0H
	sub	esp, 36					; 00000024H
	push	ebx
	push	esi
	push	edi
	mov	ebx, ecx

; 464  : 	Lock();

	call	?Lock@Mesh@@QAEXXZ			; Mesh::Lock

; 465  : 	for (int i = 0; i < VertexCount; ++i)

	xor	eax, eax
	mov	DWORD PTR _i$18034[esp+48], eax
	cmp	DWORD PTR [ebx], eax
	jle	SHORT $LN1@Transform

; 464  : 	Lock();

	mov	DWORD PTR tv150[esp+48], eax
$LN3@Transform:

; 466  : 	{
; 467  : 		VertexBuffer[i].Position = transform * VertexBuffer[i].Position;

	mov	eax, DWORD PTR [ebx+12]
	add	eax, DWORD PTR tv150[esp+48]
	mov	ecx, DWORD PTR _transform$[ebp]
	push	eax
	lea	eax, DWORD PTR $T18038[esp+52]
	push	eax
	call	??DMatrix@@QBE?AUvec4@@ABU1@@Z		; Matrix::operator*
	mov	edi, DWORD PTR [ebx+12]
	add	edi, DWORD PTR tv150[esp+48]
	inc	DWORD PTR _i$18034[esp+48]
	add	DWORD PTR tv150[esp+48], 32		; 00000020H
	mov	esi, eax
	mov	eax, DWORD PTR _i$18034[esp+48]
	movsd
	movsd
	movsd
	movsd
	cmp	eax, DWORD PTR [ebx]
	jl	SHORT $LN3@Transform
$LN1@Transform:

; 468  : 	}
; 469  : 	Unlock();

	mov	ecx, ebx
	call	?Unlock@Mesh@@QAEXXZ			; Mesh::Unlock

; 470  : }

	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	4
?Transform@Mesh@@QAEXABUMatrix@@@Z ENDP			; Mesh::Transform
compile	ENDS
PUBLIC	??0OpInfo@Mesh@@QAE@XZ				; Mesh::OpInfo::OpInfo
; Function compile flags: /Ogspy
;	COMDAT ??0OpInfo@Mesh@@QAE@XZ
compile	SEGMENT
??0OpInfo@Mesh@@QAE@XZ PROC				; Mesh::OpInfo::OpInfo, COMDAT
; _this$ = ecx
	push	ebx
	push	esi
	push	edi
	mov	edi, ecx
	mov	esi, edi
	mov	ebx, 65535				; 0000ffffH
$LL4@OpInfo:
	mov	ecx, esi
	call	??0vec4@@QAE@XZ				; vec4::vec4
	lea	ecx, DWORD PTR [esi+16]
	call	??0vec4@@QAE@XZ				; vec4::vec4
	add	esi, 32					; 00000020H
	dec	ebx
	jns	SHORT $LL4@OpInfo
	mov	eax, edi
	pop	edi
	pop	esi
	pop	ebx
	ret	0
??0OpInfo@Mesh@@QAE@XZ ENDP				; Mesh::OpInfo::OpInfo
compile	ENDS
PUBLIC	?Triangulate@Mesh@@AAEXXZ			; Mesh::Triangulate
; Function compile flags: /Ogspy
compile	SEGMENT
_firstVertex$17842 = -12				; size = 4
_count$17841 = -8					; size = 4
_j$17844 = -4						; size = 4
?Triangulate@Mesh@@AAEXXZ PROC				; Mesh::Triangulate
; _this$ = ecx

; 102  : {

	push	ebp
	mov	ebp, esp
	sub	esp, 12					; 0000000cH
	push	esi
	mov	esi, ecx

; 103  : 	OP.Reset();

	lea	ecx, DWORD PTR [esi+32]
	call	?Reset@OpInfo@Mesh@@QAEXXZ		; Mesh::OpInfo::Reset

; 104  : 	OP.NextVertexCount = 0;

	xor	eax, eax
	mov	DWORD PTR [esi+2687008], eax

; 105  : 	OP.NextFaceCount = 0;

	mov	DWORD PTR [esi+2687016], eax

; 106  : 	for (int i = 0; i < IndexCount;)

	cmp	DWORD PTR [esi+4], eax
	jle	$LN4@Triangulat
	mov	ecx, DWORD PTR [esi+16]
	push	ebx
	push	edi
$LL5@Triangulat:

; 107  : 	{
; 108  : 		int count = IndexBuffer[i++];

	movzx	edx, WORD PTR [ecx+eax*2]

; 109  : 		int firstVertex = IndexBuffer[i++];
; 110  : 		int secondVertex = IndexBuffer[i++];

	movzx	edi, WORD PTR [ecx+eax*2+4]

; 111  : 		int j = 0;

	and	DWORD PTR _j$17844[ebp], 0
	mov	DWORD PTR _count$17841[ebp], edx
	movzx	edx, WORD PTR [ecx+eax*2+2]
	mov	DWORD PTR _firstVertex$17842[ebp], edx
	lea	edx, DWORD PTR [eax+eax+6]
$LL3@Triangulat:

; 112  : 		do
; 113  : 		{
; 114  : 			OP.NextIB[OP.NextIndexCount++] = firstVertex;

	mov	ecx, DWORD PTR [esi+2687012]
	mov	bx, WORD PTR _firstVertex$17842[ebp]
	mov	WORD PTR [esi+ecx*2+2097184], bx
	inc	DWORD PTR [esi+2687012]
	mov	ecx, DWORD PTR [esi+2687012]

; 115  : 			OP.NextIB[OP.NextIndexCount++] = secondVertex;
; 116  : 			OP.NextIB[OP.NextIndexCount++] = IndexBuffer[i + j];
; 117  : 			OP.NextFaceCount++;
; 118  : 			secondVertex = IndexBuffer[i + j++];
; 119  : 		} while (j < count - 2);

	mov	ebx, DWORD PTR _count$17841[ebp]
	mov	WORD PTR [esi+ecx*2+2097184], di
	inc	DWORD PTR [esi+2687012]
	mov	edi, DWORD PTR [esi+16]
	mov	di, WORD PTR [edx+edi]
	mov	ecx, DWORD PTR [esi+2687012]
	mov	WORD PTR [esi+ecx*2+2097184], di
	inc	DWORD PTR [esi+2687012]
	inc	DWORD PTR [esi+2687016]
	mov	ecx, DWORD PTR [esi+16]
	movzx	edi, WORD PTR [edx+ecx]
	inc	DWORD PTR _j$17844[ebp]
	add	ebx, -2					; fffffffeH
	add	edx, 2
	cmp	DWORD PTR _j$17844[ebp], ebx
	jl	SHORT $LL3@Triangulat

; 120  : 		i += count - 2;

	mov	edx, DWORD PTR _count$17841[ebp]
	lea	eax, DWORD PTR [eax+edx+1]
	cmp	eax, DWORD PTR [esi+4]
	jl	$LL5@Triangulat
	pop	edi
	pop	ebx
$LN4@Triangulat:

; 121  : 	}
; 122  : 
; 123  : 	memcpy(IndexBuffer, OP.NextIB, MaxIndexBuffer * sizeof(unsigned short));

	push	589824					; 00090000H
	lea	eax, DWORD PTR [esi+2097184]
	push	eax
	push	DWORD PTR [esi+16]
	call	_memcpy

; 124  : 	IndexCount = OP.NextIndexCount;

	mov	eax, DWORD PTR [esi+2687012]
	mov	DWORD PTR [esi+4], eax

; 125  : 	FaceCount = OP.NextFaceCount;

	mov	eax, DWORD PTR [esi+2687016]
	add	esp, 12					; 0000000cH
	mov	DWORD PTR [esi+8], eax
	pop	esi

; 126  : }

	leave
	ret	0
?Triangulate@Mesh@@AAEXXZ ENDP				; Mesh::Triangulate
compile	ENDS
PUBLIC	__real@3f000000
PUBLIC	?CatmullClarkSubdivide@Mesh@@AAEXXZ		; Mesh::CatmullClarkSubdivide
EXTRN	??Dvec4@@QBE?AU0@M@Z:PROC			; vec4::operator*
EXTRN	??_0vec4@@QAEXM@Z:PROC				; vec4::operator/=
;	COMDAT __real@3f000000
CONST	SEGMENT
__real@3f000000 DD 03f000000r			; 0.5
; Function compile flags: /Ogspy
CONST	ENDS
compile	SEGMENT
tv1252 = -220						; size = 4
tv991 = -220						; size = 4
tv730 = -220						; size = 4
tv529 = -220						; size = 4
_openEdgeCount$17883 = -220				; size = 4
tv1155 = -216						; size = 4
tv1143 = -216						; size = 4
tv995 = -216						; size = 4
tv890 = -216						; size = 4
tv1138 = -212						; size = 4
_i$17855 = -212						; size = 4
_i$17875 = -208						; size = 4
_count$17859 = -208					; size = 4
_openEdges$17879 = -201					; size = 1
tv1216 = -200						; size = 4
tv1197 = -200						; size = 4
tv1145 = -200						; size = 4
tv642 = -200						; size = 4
_V1$17914 = -200					; size = 4
tv1290 = -196						; size = 4
tv1018 = -196						; size = 4
_index$17866 = -196					; size = 4
_edgeCount$17882 = -192					; size = 4
_face$ = -192						; size = 4
tv1250 = -188						; size = 4
_fp$17860 = -188					; size = 4
tv667 = -184						; size = 4
_V2$17915 = -184					; size = 4
_ib$17861 = -180					; size = 4
_edgesVector$17880 = -176				; size = 16
_mid$17892 = -160					; size = 16
_openEdgesVector$17881 = -144				; size = 16
$T17917 = -128						; size = 16
$T17902 = -128						; size = 16
$T17897 = -112						; size = 16
$T17908 = -96						; size = 16
$T17904 = -80						; size = 16
$T17907 = -64						; size = 16
$T17905 = -48						; size = 16
$T17898 = -32						; size = 16
$T17899 = -16						; size = 16
?CatmullClarkSubdivide@Mesh@@AAEXXZ PROC		; Mesh::CatmullClarkSubdivide
; _this$ = ecx

; 130  : {

	push	ebp
	mov	ebp, esp
	and	esp, -16				; fffffff0H
	sub	esp, 228				; 000000e4H
	push	ebx
	mov	ebx, ecx

; 131  : 	if (IndexCount >= MaxIndexBuffer / 4 || VertexCount >= MaxVertexBuffer * 9 / 4)

	cmp	DWORD PTR [ebx+4], 73728		; 00012000H
	push	esi
	push	edi
	jge	$LN24@CatmullCla
	cmp	DWORD PTR [ebx], 147456			; 00024000H
	jge	$LN24@CatmullCla

; 132  : 	{
; 133  : 		return;
; 134  : 	}
; 135  : 
; 136  : 	// neuer VB ist so:
; 137  : 	// alter VB bzw. verschobene Originalpunkte
; 138  : 	// ein Vertex pro Face (FacePunkte)
; 139  : 	// ein Vertex pro Edge (EdgePunkte)
; 140  : 
; 141  : 	//neuer IB ist so:
; 142  : 	// 4 / alte Ecke0 / EdgePunkt / FaceFacePunkt / EdgePunkt
; 143  : 	// 4 / alte Ecke1 / EdgePunkt / FaceFacePunkt / EdgePunkt
; 144  : 	//...
; 145  : 	// 4 / alte EckeN / EdgePunkt / FaceFacePunkt / EdgePunkt (N = = Vertexcount)
; 146  : 	//beim kopieren dann ueberall noch 4
; 147  : 
; 148  : 	OP.Reset();

	lea	ecx, DWORD PTR [ebx+32]
	call	?Reset@OpInfo@Mesh@@QAEXXZ		; Mesh::OpInfo::Reset

; 149  : 	OP.NextVertexCount = VertexCount + FaceCount; //Basis Vertices sind die alte Ecken und die neuen FacePunkte

	mov	eax, DWORD PTR [ebx]
	add	eax, DWORD PTR [ebx+8]
	mov	DWORD PTR [ebx+2687008], eax

; 150  : 
; 151  : 	int face = 0;

	xor	eax, eax
	mov	DWORD PTR _face$[esp+240], eax

; 152  : 	for (int i = 0; i < IndexCount;)

	cmp	DWORD PTR [ebx+4], eax
	jle	$LN22@CatmullCla
	jmp	SHORT $LN23@CatmullCla
$LL43@CatmullCla:
	mov	eax, DWORD PTR _i$17855[esp+240]
$LN23@CatmullCla:

; 155  : 		vec4& fp = OP.NextVB[VertexCount + face].Position;

	mov	edx, DWORD PTR [ebx]
	mov	esi, DWORD PTR _face$[esp+240]
	mov	ecx, DWORD PTR [ebx+16]
	movzx	ecx, WORD PTR [ecx+eax*2]
	lea	esi, DWORD PTR [edx+esi+1]

; 156  : 		unsigned short int* ib = OP.NextIB + OP.NextIndexCount;

	mov	edx, DWORD PTR [ebx+2687012]
	shl	esi, 5
	inc	eax
	add	esi, ebx
	lea	edi, DWORD PTR [ebx+edx*2+2097184]
	mov	DWORD PTR _count$17859[esp+240], ecx
	mov	DWORD PTR _i$17855[esp+240], eax
	mov	DWORD PTR _fp$17860[esp+240], esi
	mov	DWORD PTR _ib$17861[esp+240], edi

; 157  : 
; 158  : 		for (int j = 0; j < count; ++j)

	test	ecx, ecx
	jle	SHORT $LN19@CatmullCla

; 153  : 	{
; 154  : 		int count = IndexBuffer[i++];

	add	eax, eax
	mov	DWORD PTR tv890[esp+240], eax
	add	edi, 6
	mov	DWORD PTR tv529[esp+240], ecx
$LN21@CatmullCla:

; 159  : 		{
; 160  : 			int index = IndexBuffer[i + j];

	mov	eax, DWORD PTR [ebx+16]
	mov	ecx, DWORD PTR tv890[esp+240]
	movzx	eax, WORD PTR [ecx+eax]
	mov	DWORD PTR _index$17866[esp+240], eax

; 161  : 			fp += VertexBuffer[index].Position;

	shl	eax, 5
	add	eax, DWORD PTR [ebx+12]
	mov	ecx, esi
	push	eax
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=
	add	DWORD PTR tv890[esp+240], 2

; 162  : 			ib[j * 5] = 4;

	push	4
	pop	eax
	mov	WORD PTR [edi-6], ax

; 163  : 			ib[j * 5 + 1] = index;

	mov	ax, WORD PTR _index$17866[esp+240]
	mov	WORD PTR [edi-4], ax

; 164  : 			ib[j * 5 + 3] = VertexCount + face; // erste Haelfte IB fertig

	mov	ax, WORD PTR [ebx]
	add	ax, WORD PTR _face$[esp+240]
	mov	WORD PTR [edi], ax
	add	edi, 10					; 0000000aH
	dec	DWORD PTR tv529[esp+240]
	jne	SHORT $LN21@CatmullCla
$LN19@CatmullCla:

; 165  : 		}
; 166  : 		fp /= (float)count; // jetzt ist der FacePunkt fertig

	fild	DWORD PTR _count$17859[esp+240]
	push	ecx
	mov	ecx, esi
	fstp	DWORD PTR [esp]
	call	??_0vec4@@QAEXM@Z			; vec4::operator/=

; 167  : 
; 168  : 		for (int j = 0; j < count; ++j)

	mov	ecx, DWORD PTR _count$17859[esp+240]
	xor	eax, eax
	test	ecx, ecx
	jle	$LN16@CatmullCla

; 165  : 		}
; 166  : 		fp /= (float)count; // jetzt ist der FacePunkt fertig

	imul	ecx, 5
	mov	DWORD PTR tv667[esp+240], ecx
	mov	ecx, DWORD PTR _i$17855[esp+240]
	add	ecx, ecx
	mov	DWORD PTR tv995[esp+240], ecx
	mov	ecx, DWORD PTR _ib$17861[esp+240]
	add	ecx, 4
	mov	DWORD PTR tv991[esp+240], 9
	mov	DWORD PTR tv1018[esp+240], ecx
$LN18@CatmullCla:

; 169  : 		{
; 170  : 			int index = IndexBuffer[i + j];

	mov	ecx, DWORD PTR [ebx+16]
	mov	edx, DWORD PTR tv995[esp+240]
	movzx	edi, WORD PTR [edx+ecx]

; 171  : 			int indexNext = IndexBuffer[i + ((j + 1) % count)];

	inc	eax
	mov	DWORD PTR tv642[esp+240], eax
	cdq
	idiv	DWORD PTR _count$17859[esp+240]
	add	edx, DWORD PTR _i$17855[esp+240]
	movzx	eax, WORD PTR [ecx+edx*2]

; 172  : 			int Edge = OP.MakeEdgeID(index, indexNext);

	push	eax
	push	edi
	lea	ecx, DWORD PTR [ebx+32]
	call	?MakeEdgeID@OpInfo@Mesh@@QAEHGG@Z	; Mesh::OpInfo::MakeEdgeID

; 173  : 			OP.NextVB[OP.EdgeID[Edge]].Position += fp; // Summe aller FacePunkte zu dieser Ecke sind hier

	push	DWORD PTR _fp$17860[esp+240]
	lea	esi, DWORD PTR [ebx+eax*2+4161584]
	movzx	ecx, WORD PTR [esi]
	inc	ecx
	shl	ecx, 5
	add	ecx, ebx
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=

; 174  : 
; 175  : 			ib[j * 5 + 2] = OP.EdgeID[Edge];

	mov	ax, WORD PTR [esi]
	mov	ecx, DWORD PTR tv1018[esp+240]
	mov	WORD PTR [ecx], ax

; 176  : 			ib[(j * 5 + 9) % (count * 5)] = OP.EdgeID[Edge]; // IB fertig!

	mov	eax, DWORD PTR tv991[esp+240]
	cdq
	idiv	DWORD PTR tv667[esp+240]
	mov	ax, WORD PTR [esi]
	mov	ecx, DWORD PTR _ib$17861[esp+240]

; 177  : 
; 178  : 			OP.NextVB[index].Position += fp; //Summe aller FacePunkte die an diesen Originalpunkt grenzen

	push	DWORD PTR _fp$17860[esp+240]
	mov	WORD PTR [ecx+edx*2], ax
	lea	ecx, DWORD PTR [edi+1]
	shl	ecx, 5
	add	ecx, ebx
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=
	mov	eax, DWORD PTR tv642[esp+240]
	add	DWORD PTR tv995[esp+240], 2
	add	DWORD PTR tv1018[esp+240], 10		; 0000000aH
	add	DWORD PTR tv991[esp+240], 5
	cmp	eax, DWORD PTR _count$17859[esp+240]
	jl	$LN18@CatmullCla
$LN16@CatmullCla:

; 179  : 		}
; 180  : 
; 181  : 		i += count;

	mov	eax, DWORD PTR _count$17859[esp+240]
	add	DWORD PTR _i$17855[esp+240], eax

; 182  : 		face++;
; 183  : 		OP.NextIndexCount += count * 5;
; 184  : 		OP.NextFaceCount += count;

	add	DWORD PTR [ebx+2687016], eax
	inc	DWORD PTR _face$[esp+240]
	mov	ecx, eax
	mov	eax, DWORD PTR _i$17855[esp+240]
	imul	ecx, 5
	add	DWORD PTR [ebx+2687012], ecx
	cmp	eax, DWORD PTR [ebx+4]
	jl	$LL43@CatmullCla
$LN22@CatmullCla:

; 185  : 	}
; 186  : 
; 187  : 	// Originalpunkte verschieben
; 188  : 	for (int i = 0; i < VertexCount; ++i)

	and	DWORD PTR _i$17875[esp+240], 0
	fldz
	cmp	DWORD PTR [ebx], 0
	jle	$LN13@CatmullCla
	lea	eax, DWORD PTR [ebx+32]
	mov	DWORD PTR tv1143[esp+240], -32		; ffffffe0H
	sub	DWORD PTR tv1143[esp+240], ebx
	mov	DWORD PTR tv1138[esp+240], eax
$LL15@CatmullCla:

; 191  : 		vec4 edgesVector(0,0,0,0);

	sub	esp, 16					; 00000010H
	fst	DWORD PTR [esp+12]
	lea	ecx, DWORD PTR _edgesVector$17880[esp+256]
	fst	DWORD PTR [esp+8]
	mov	BYTE PTR _openEdges$17879[esp+256], 0
	fst	DWORD PTR [esp+4]
	fstp	DWORD PTR [esp]
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4

; 192  : 		vec4 openEdgesVector(0,0,0,0);

	fldz
	sub	esp, 16					; 00000010H
	fst	DWORD PTR [esp+12]
	lea	ecx, DWORD PTR _openEdgesVector$17881[esp+256]
	fst	DWORD PTR [esp+8]
	fst	DWORD PTR [esp+4]
	fstp	DWORD PTR [esp]
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4

; 193  : 		int edgeCount = 0;

	xor	edi, edi
	mov	DWORD PTR _edgeCount$17882[esp+240], edi

; 194  : 		int openEdgeCount = 0;

	mov	DWORD PTR _openEdgeCount$17883[esp+240], edi

; 195  : 
; 196  : 		for (int j = 0; j < OP.EdgeCount; ++j)

	cmp	DWORD PTR [ebx+2687020], edi
	jle	$LN6@CatmullCla

; 189  : 	{
; 190  : 		bool openEdges = false; // gab es offene Kanten (d.h. einseitig benutze?)

	lea	esi, DWORD PTR [ebx+2687024]
$LL12@CatmullCla:

; 197  : 		{
; 198  : 			int V1 = (OP.EdgeConfiguration[j] & 0x0000ffff);

	mov	ecx, DWORD PTR [esi]

; 199  : 			int V2 = (OP.EdgeConfiguration[j] & 0xffff0000) >> 16;

	movzx	eax, WORD PTR [esi+2]
	and	ecx, 65535				; 0000ffffH

; 200  : 			if (V1 == i || V2 == i)

	cmp	ecx, DWORD PTR _i$17875[esp+240]
	je	SHORT $LN8@CatmullCla
	cmp	eax, DWORD PTR _i$17875[esp+240]
	jne	SHORT $LN11@CatmullCla
$LN8@CatmullCla:

; 201  : 			{
; 202  : 				vec4 mid = VertexBuffer[V1].Position + VertexBuffer[V2].Position;

	mov	edx, DWORD PTR [ebx+12]
	shl	eax, 5
	add	eax, edx
	push	eax
	lea	eax, DWORD PTR _mid$17892[esp+244]
	shl	ecx, 5
	push	eax
	add	ecx, edx
	call	??Hvec4@@QBE?AU0@ABU0@@Z		; vec4::operator+

; 203  : 				if (OP.EdgeUsage[j] == 1)

	cmp	BYTE PTR [edi+ebx+3866672], 1
	jne	SHORT $LN7@CatmullCla

; 204  : 				{
; 205  : 					openEdges = true;
; 206  : 					openEdgeCount++;

	inc	DWORD PTR _openEdgeCount$17883[esp+240]

; 207  : 					openEdgesVector += mid;

	lea	eax, DWORD PTR _mid$17892[esp+240]
	push	eax
	lea	ecx, DWORD PTR _openEdgesVector$17881[esp+244]
	mov	BYTE PTR _openEdges$17879[esp+244], 1
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=
$LN7@CatmullCla:

; 208  : 				}
; 209  : 				edgeCount++;

	inc	DWORD PTR _edgeCount$17882[esp+240]

; 210  : 				edgesVector += mid;

	lea	eax, DWORD PTR _mid$17892[esp+240]
	push	eax
	lea	ecx, DWORD PTR _edgesVector$17880[esp+244]
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=
$LN11@CatmullCla:

; 195  : 
; 196  : 		for (int j = 0; j < OP.EdgeCount; ++j)

	inc	edi
	add	esi, 4
	cmp	edi, DWORD PTR [ebx+2687020]
	jl	SHORT $LL12@CatmullCla

; 211  : 			}
; 212  : 		}
; 213  : 
; 214  : 		if (openEdges)

	cmp	BYTE PTR _openEdges$17879[esp+240], 0
	je	SHORT $LN6@CatmullCla

; 215  : 		{
; 216  : 			OP.NextVB[i].Position = openEdgesVector / (float)(openEdgeCount * 4) + VertexBuffer[i].Position * 0.5f;

	fld	DWORD PTR __real@3f000000
	mov	edi, DWORD PTR tv1138[esp+240]
	push	ecx
	mov	ecx, DWORD PTR [ebx+12]
	fstp	DWORD PTR [esp]
	add	ecx, DWORD PTR tv1143[esp+244]
	lea	eax, DWORD PTR $T17898[esp+244]
	push	eax
	add	ecx, edi
	call	??Dvec4@@QBE?AU0@M@Z			; vec4::operator*
	push	eax
	lea	eax, DWORD PTR $T17899[esp+244]
	push	eax
	mov	eax, DWORD PTR _openEdgeCount$17883[esp+248]
	shl	eax, 2
	mov	DWORD PTR tv1216[esp+248], eax
	fild	DWORD PTR tv1216[esp+248]
	push	ecx
	lea	eax, DWORD PTR $T17897[esp+252]
	lea	ecx, DWORD PTR _openEdgesVector$17881[esp+252]
	fstp	DWORD PTR [esp]
	push	eax
	call	??Kvec4@@QBE?AU0@M@Z			; vec4::operator/
	mov	ecx, eax
	call	??Hvec4@@QBE?AU0@ABU0@@Z		; vec4::operator+
	mov	esi, eax
	movsd
	movsd
	movsd
	movsd

; 217  : 		}
; 218  : 		else

	jmp	$LN14@CatmullCla
$LN6@CatmullCla:

; 219  : 		{
; 220  : 			OP.NextVB[i].Position = 	
; 221  : 				OP.NextVB[i].Position / (float)edgeCount + 
; 222  : 				edgesVector / (float)edgeCount +
; 223  : 				VertexBuffer[i].Position * (float)(edgeCount - 3);

	mov	eax, DWORD PTR _edgeCount$17882[esp+240]
	fild	DWORD PTR _edgeCount$17882[esp+240]
	push	ecx
	mov	ecx, DWORD PTR [ebx+12]
	add	ecx, DWORD PTR tv1143[esp+244]
	fstp	DWORD PTR tv730[esp+244]
	add	eax, -3					; fffffffdH
	add	ecx, DWORD PTR tv1138[esp+244]
	mov	DWORD PTR tv1197[esp+244], eax
	fild	DWORD PTR tv1197[esp+244]
	lea	eax, DWORD PTR $T17907[esp+244]
	fstp	DWORD PTR [esp]
	push	eax
	call	??Dvec4@@QBE?AU0@M@Z			; vec4::operator*
	fld	DWORD PTR tv730[esp+240]
	push	eax
	lea	eax, DWORD PTR $T17908[esp+244]
	push	eax
	push	ecx
	lea	eax, DWORD PTR $T17904[esp+252]
	fstp	DWORD PTR [esp]
	push	eax
	lea	ecx, DWORD PTR _edgesVector$17880[esp+256]
	call	??Kvec4@@QBE?AU0@M@Z			; vec4::operator/
	fld	DWORD PTR tv730[esp+248]
	push	eax
	lea	eax, DWORD PTR $T17905[esp+252]
	push	eax
	push	ecx
	mov	ecx, DWORD PTR tv1138[esp+260]
	fstp	DWORD PTR [esp]
	lea	eax, DWORD PTR $T17902[esp+260]
	push	eax
	call	??Kvec4@@QBE?AU0@M@Z			; vec4::operator/
	mov	ecx, eax
	call	??Hvec4@@QBE?AU0@ABU0@@Z		; vec4::operator+
	mov	ecx, eax
	call	??Hvec4@@QBE?AU0@ABU0@@Z		; vec4::operator+

; 224  : 			OP.NextVB[i].Position /= (float)edgeCount;

	fld	DWORD PTR tv730[esp+240]
	mov	edi, DWORD PTR tv1138[esp+240]
	mov	esi, eax
	movsd
	movsd
	movsd
	push	ecx
	mov	ecx, DWORD PTR tv1138[esp+244]
	movsd
	fstp	DWORD PTR [esp]
	call	??_0vec4@@QAEXM@Z			; vec4::operator/=
$LN14@CatmullCla:

; 185  : 	}
; 186  : 
; 187  : 	// Originalpunkte verschieben
; 188  : 	for (int i = 0; i < VertexCount; ++i)

	inc	DWORD PTR _i$17875[esp+240]
	fldz
	mov	eax, DWORD PTR _i$17875[esp+240]
	add	DWORD PTR tv1138[esp+240], 32		; 00000020H
	cmp	eax, DWORD PTR [ebx]
	jl	$LL15@CatmullCla
$LN13@CatmullCla:

; 225  : 		}
; 226  : 	}
; 227  : 
; 228  : 	//EdgePunkte anpassen
; 229  : 	for (int j = 0; j < OP.EdgeCount; ++j)

	cmp	DWORD PTR [ebx+2687020], 0
	jle	$LN51@CatmullCla
	lea	eax, DWORD PTR [ebx+3866672]
	lea	edi, DWORD PTR [ebx+4161584]
	lea	ecx, DWORD PTR [ebx+2687024]
	mov	DWORD PTR tv1290[esp+240], -3866672	; ffc4ffd0H
	sub	DWORD PTR tv1290[esp+240], ebx
	mov	DWORD PTR tv1155[esp+240], eax
	mov	DWORD PTR tv1250[esp+240], edi
	mov	DWORD PTR tv1252[esp+240], ecx
	jmp	SHORT $LN4@CatmullCla
$LL41@CatmullCla:
	fldz
	mov	ecx, DWORD PTR tv1252[esp+240]
$LN4@CatmullCla:

; 230  : 	{
; 231  : 		int V1 = (OP.EdgeConfiguration[j] & 0x0000ffff);

	mov	eax, DWORD PTR [ecx]

; 232  : 		int V2 = (OP.EdgeConfiguration[j] & 0xffff0000) >> 16;

	movzx	esi, WORD PTR [ecx+2]

; 233  : 		if (OP.EdgeUsage[j] < 2)

	mov	ecx, DWORD PTR tv1155[esp+240]
	and	eax, 65535				; 0000ffffH
	cmp	BYTE PTR [ecx], 2
	mov	DWORD PTR _V1$17914[esp+240], eax
	mov	DWORD PTR _V2$17915[esp+240], esi
	jae	SHORT $LN55@CatmullCla

; 234  : 		{
; 235  : 			OP.NextVB[OP.EdgeID[j]].Position = vec4(0,0,0,0);

	sub	esp, 16					; 00000010H
	fst	DWORD PTR [esp+12]
	lea	ecx, DWORD PTR $T17917[esp+256]
	fst	DWORD PTR [esp+8]
	fst	DWORD PTR [esp+4]
	fstp	DWORD PTR [esp]
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4
	movzx	edi, WORD PTR [edi]
	inc	edi
	shl	edi, 5
	add	edi, ebx
	mov	esi, eax

; 236  : 			OP.EdgeUsage[j] = 0;

	mov	eax, DWORD PTR tv1155[esp+240]
	movsd
	movsd
	movsd
	movsd
	mov	edi, DWORD PTR tv1250[esp+240]
	mov	esi, DWORD PTR _V2$17915[esp+240]
	mov	BYTE PTR [eax], 0
	mov	eax, DWORD PTR _V1$17914[esp+240]
	jmp	SHORT $LN1@CatmullCla
$LN55@CatmullCla:
	fstp	ST(0)
$LN1@CatmullCla:

; 237  : 		}
; 238  : 		
; 239  : 		OP.NextVB[OP.EdgeID[j]].Position += VertexBuffer[V1].Position;

	movzx	ecx, WORD PTR [edi]
	shl	eax, 5
	add	eax, DWORD PTR [ebx+12]
	inc	ecx
	shl	ecx, 5
	push	eax
	add	ecx, ebx
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=

; 240  : 		OP.NextVB[OP.EdgeID[j]].Position += VertexBuffer[V2].Position;

	movzx	ecx, WORD PTR [edi]
	shl	esi, 5
	add	esi, DWORD PTR [ebx+12]
	inc	ecx
	shl	ecx, 5
	push	esi
	add	ecx, ebx
	call	??Yvec4@@QAEXABU0@@Z			; vec4::operator+=

; 241  : 		OP.NextVB[OP.EdgeID[j]].Position /= (float)(OP.EdgeUsage[j] + 2);

	mov	esi, DWORD PTR tv1155[esp+240]
	movzx	eax, BYTE PTR [esi]
	push	ecx
	movzx	ecx, WORD PTR [edi]
	add	eax, 2
	mov	DWORD PTR tv1145[esp+244], eax
	inc	ecx
	shl	ecx, 5
	fild	DWORD PTR tv1145[esp+244]
	add	ecx, ebx
	fstp	DWORD PTR [esp]
	call	??_0vec4@@QAEXM@Z			; vec4::operator/=
	add	DWORD PTR tv1252[esp+240], 4
	mov	eax, DWORD PTR tv1290[esp+240]
	add	edi, 2
	inc	esi
	add	eax, esi
	mov	DWORD PTR tv1250[esp+240], edi
	mov	DWORD PTR tv1155[esp+240], esi
	cmp	eax, DWORD PTR [ebx+2687020]
	jl	$LL41@CatmullCla

; 225  : 		}
; 226  : 	}
; 227  : 
; 228  : 	//EdgePunkte anpassen
; 229  : 	for (int j = 0; j < OP.EdgeCount; ++j)

	jmp	SHORT $LN2@CatmullCla
$LN51@CatmullCla:
	fstp	ST(0)
$LN2@CatmullCla:

; 242  : 	}
; 243  : 
; 244  : 	memcpy(VertexBuffer, OP.NextVB, MaxVertexBuffer * sizeof(MeshVertex));

	push	2097152					; 00200000H
	lea	eax, DWORD PTR [ebx+32]
	push	eax
	push	DWORD PTR [ebx+12]
	call	_memcpy

; 245  : 	memcpy(IndexBuffer, OP.NextIB, MaxIndexBuffer * sizeof(unsigned short));

	push	589824					; 00090000H
	lea	eax, DWORD PTR [ebx+2097184]
	push	eax
	push	DWORD PTR [ebx+16]
	call	_memcpy

; 246  : 	VertexCount = OP.NextVertexCount;

	mov	eax, DWORD PTR [ebx+2687008]
	mov	DWORD PTR [ebx], eax

; 247  : 	IndexCount = OP.NextIndexCount;

	mov	eax, DWORD PTR [ebx+2687012]
	mov	DWORD PTR [ebx+4], eax

; 248  : 	FaceCount = OP.NextFaceCount;

	mov	eax, DWORD PTR [ebx+2687016]
	add	esp, 24					; 00000018H
	mov	DWORD PTR [ebx+8], eax
$LN24@CatmullCla:

; 249  : }

	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	0
?CatmullClarkSubdivide@Mesh@@AAEXXZ ENDP		; Mesh::CatmullClarkSubdivide
compile	ENDS
PUBLIC	?Extrude@Mesh@@AAEXM@Z				; Mesh::Extrude
; Function compile flags: /Ogspy
compile	SEGMENT
tv377 = -20						; size = 4
_indexNext$17935 = -16					; size = 4
tv672 = -12						; size = 4
_count$17929 = -12					; size = 4
tv697 = -8						; size = 4
tv575 = -8						; size = 4
tv624 = -4						; size = 4
_j$17930 = -4						; size = 4
_iAdd$17947 = 8						; size = 4
_fExtend$ = 8						; size = 4
?Extrude@Mesh@@AAEXM@Z PROC				; Mesh::Extrude
; _this$ = ecx

; 253  : {

	push	ebp
	mov	ebp, esp
	sub	esp, 20					; 00000014H
	push	ebx
	push	esi
	mov	ebx, ecx
	push	edi

; 254  : 	OP.Reset();

	lea	ecx, DWORD PTR [ebx+32]
	call	?Reset@OpInfo@Mesh@@QAEXXZ		; Mesh::OpInfo::Reset

; 255  : 
; 256  : 	for (int i = 0; i < IndexCount;)

	xor	esi, esi
	cmp	DWORD PTR [ebx+4], esi
	jle	$LN12@Extrude
$LL13@Extrude:

; 257  : 	{
; 258  : 		int count = IndexBuffer[i];

	mov	ecx, DWORD PTR [ebx+16]
	movzx	eax, WORD PTR [ecx+esi*2]

; 259  : 		IndexBuffer[i + IndexCount] = count;

	mov	edx, DWORD PTR [ebx+4]

; 260  : 		++i;
; 261  : 
; 262  : 		for (int j = 0; j < count; ++j)

	and	DWORD PTR _j$17930[ebp], 0
	add	edx, esi
	inc	esi
	mov	DWORD PTR _count$17929[ebp], eax
	mov	WORD PTR [ecx+edx*2], ax
	test	eax, eax
	jle	SHORT $LN9@Extrude

; 257  : 	{
; 258  : 		int count = IndexBuffer[i];

	lea	eax, DWORD PTR [esi+esi]
	mov	DWORD PTR tv575[ebp], eax
$LL26@Extrude:

; 263  : 		{
; 264  : 			int index = IndexBuffer[i + j];

	mov	ecx, DWORD PTR [ebx+16]
	mov	eax, DWORD PTR tv575[ebp]
	movzx	edi, WORD PTR [eax+ecx]

; 265  : 			int indexNext = IndexBuffer[i + ((j + 1) % count)];

	mov	eax, DWORD PTR _j$17930[ebp]
	inc	eax
	mov	DWORD PTR tv377[ebp], eax
	cdq
	idiv	DWORD PTR _count$17929[ebp]
	add	edx, esi
	movzx	eax, WORD PTR [ecx+edx*2]

; 266  : 			int ID = OP.MakeEdgeID(index, indexNext);

	push	eax
	push	edi
	lea	ecx, DWORD PTR [ebx+32]
	mov	DWORD PTR _indexNext$17935[ebp], eax
	call	?MakeEdgeID@OpInfo@Mesh@@QAEHGG@Z	; Mesh::OpInfo::MakeEdgeID

; 267  : 			if (index > indexNext)

	cmp	edi, DWORD PTR _indexNext$17935[ebp]
	jle	SHORT $LN8@Extrude

; 268  : 			{
; 269  : 				OP.EdgeUsage[ID] += 0x80;

	lea	eax, DWORD PTR [eax+ebx+3866672]
	sub	BYTE PTR [eax], -128			; ffffff80H
$LN8@Extrude:

; 270  : 			}
; 271  : 			IndexBuffer[i + IndexCount + count - j - 1] = index + VertexCount;

	mov	edx, DWORD PTR [ebx+4]
	sub	edx, DWORD PTR _j$17930[ebp]
	mov	cx, WORD PTR [ebx]
	mov	eax, DWORD PTR _count$17929[ebp]
	add	DWORD PTR tv575[ebp], 2
	add	cx, di
	mov	edi, DWORD PTR [ebx+16]
	add	edx, eax
	add	edx, esi
	mov	WORD PTR [edi+edx*2-2], cx
	mov	ecx, DWORD PTR tv377[ebp]
	mov	DWORD PTR _j$17930[ebp], ecx
	cmp	ecx, eax
	jl	SHORT $LL26@Extrude
$LN9@Extrude:

; 272  : 		}
; 273  : 		i += count;

	add	esi, eax
	cmp	esi, DWORD PTR [ebx+4]
	jl	$LL13@Extrude
$LN12@Extrude:

; 274  : 	}
; 275  : 
; 276  : 	for (int i = 0; i < VertexCount; ++i)

	xor	ecx, ecx
	xor	edx, edx
	cmp	DWORD PTR [ebx], ecx
	jle	SHORT $LN5@Extrude
$LL7@Extrude:

; 277  : 	{
; 278  : 		VertexBuffer[i + VertexCount].Position = VertexBuffer[i].Position;

	mov	edi, DWORD PTR [ebx]
	mov	eax, DWORD PTR [ebx+12]
	add	edi, edx
	shl	edi, 5
	add	edi, eax
	lea	esi, DWORD PTR [ecx+eax]
	movsd
	movsd
	movsd
	movsd

; 279  : 		VertexBuffer[i].Position.z -= fExtend;

	mov	eax, DWORD PTR [ebx+12]
	lea	eax, DWORD PTR [ecx+eax+8]
	add	ecx, 32					; 00000020H
	fld	DWORD PTR [eax]
	fsub	DWORD PTR _fExtend$[ebp]
	fstp	DWORD PTR [eax]

; 280  : 		VertexBuffer[i + VertexCount].Position.z += fExtend;

	mov	eax, DWORD PTR [ebx]
	mov	esi, DWORD PTR [ebx+12]
	add	eax, edx
	shl	eax, 5
	lea	eax, DWORD PTR [eax+esi+8]
	fld	DWORD PTR [eax]
	inc	edx
	fadd	DWORD PTR _fExtend$[ebp]
	fstp	DWORD PTR [eax]
	cmp	edx, DWORD PTR [ebx]
	jl	SHORT $LL7@Extrude
$LN5@Extrude:

; 281  : 	}
; 282  : 
; 283  : 	IndexCount *= 2;

	shl	DWORD PTR [ebx+4], 1

; 284  : 	FaceCount *= 2;

	shl	DWORD PTR [ebx+8], 1

; 285  : 
; 286  : 	for (int i = 0; i < OP.EdgeCount; ++i)

	cmp	DWORD PTR [ebx+2687020], 0
	jle	$LN2@Extrude

; 281  : 	}
; 282  : 
; 283  : 	IndexCount *= 2;

	lea	esi, DWORD PTR [ebx+3866672]
	lea	eax, DWORD PTR [ebx+2687024]
	mov	DWORD PTR tv697[ebp], -3866672		; ffc4ffd0H
	sub	DWORD PTR tv697[ebp], ebx
	mov	DWORD PTR tv624[ebp], esi
	mov	DWORD PTR tv672[ebp], eax
$LL28@Extrude:

; 287  : 	{
; 288  : 		if ((OP.EdgeUsage[i] & 0x7f) == 1)

	mov	cl, BYTE PTR [esi]
	mov	dl, cl
	and	dl, 127					; 0000007fH
	cmp	dl, 1
	jne	$LN3@Extrude

; 289  : 		{
; 290  : 			int iAdd = OP.EdgeUsage[i] == 1 ? 0 : VertexCount;

	cmp	cl, dl
	jne	SHORT $LN16@Extrude
	and	DWORD PTR _iAdd$17947[ebp], 0
	jmp	SHORT $LN17@Extrude
$LN16@Extrude:
	mov	ecx, DWORD PTR [ebx]
	mov	DWORD PTR _iAdd$17947[ebp], ecx
$LN17@Extrude:

; 291  : 			int V1 = (OP.EdgeConfiguration[i] & 0x0000ffff);
; 292  : 			int V2 = (OP.EdgeConfiguration[i] & 0xffff0000) >> 16;

	movzx	edx, WORD PTR [eax+2]
	mov	ecx, DWORD PTR [eax]

; 293  : 			IndexBuffer[IndexCount++] = 4;

	mov	eax, DWORD PTR [ebx+4]
	mov	esi, DWORD PTR [ebx+16]
	and	ecx, 65535				; 0000ffffH
	push	4
	pop	edi
	mov	WORD PTR [esi+eax*2], di
	inc	DWORD PTR [ebx+4]
	mov	eax, DWORD PTR [ebx+4]

; 294  : 			IndexBuffer[IndexCount++] = V1 + iAdd;

	mov	edi, DWORD PTR [ebx+16]
	mov	esi, DWORD PTR _iAdd$17947[ebp]
	add	esi, ecx
	mov	WORD PTR [edi+eax*2], si
	inc	DWORD PTR [ebx+4]

; 295  : 			iAdd = VertexCount - iAdd;

	mov	eax, DWORD PTR [ebx]
	sub	eax, DWORD PTR _iAdd$17947[ebp]
	mov	esi, DWORD PTR [ebx+4]

; 296  : 			IndexBuffer[IndexCount++] = V1 + iAdd;

	mov	edi, DWORD PTR [ebx+16]
	add	ecx, eax
	mov	WORD PTR [edi+esi*2], cx
	inc	DWORD PTR [ebx+4]
	mov	ecx, DWORD PTR [ebx+4]

; 297  : 			IndexBuffer[IndexCount++] = V2 + iAdd;

	mov	edi, DWORD PTR [ebx+16]
	lea	esi, DWORD PTR [edx+eax]
	mov	WORD PTR [edi+ecx*2], si

; 298  : 			iAdd = VertexCount - iAdd;
; 299  : 			IndexBuffer[IndexCount++] = V2 + iAdd;

	mov	si, WORD PTR [ebx]
	inc	DWORD PTR [ebx+4]
	mov	ecx, DWORD PTR [ebx+4]
	sub	si, ax
	mov	eax, DWORD PTR [ebx+16]
	add	si, dx
	mov	WORD PTR [eax+ecx*2], si
	inc	DWORD PTR [ebx+4]

; 300  : 			FaceCount += 1;

	inc	DWORD PTR [ebx+8]
	mov	eax, DWORD PTR tv672[ebp]
	mov	esi, DWORD PTR tv624[ebp]
$LN3@Extrude:

; 285  : 
; 286  : 	for (int i = 0; i < OP.EdgeCount; ++i)

	mov	ecx, DWORD PTR tv697[ebp]
	add	eax, 4
	inc	esi
	add	ecx, esi
	mov	DWORD PTR tv672[ebp], eax
	mov	DWORD PTR tv624[ebp], esi
	cmp	ecx, DWORD PTR [ebx+2687020]
	jl	$LL28@Extrude
$LN2@Extrude:

; 301  : 		}
; 302  : 	}
; 303  : 	VertexCount *= 2;

	shl	DWORD PTR [ebx], 1
	pop	edi
	pop	esi
	pop	ebx

; 304  : }

	leave
	ret	4
?Extrude@Mesh@@AAEXM@Z ENDP				; Mesh::Extrude
compile	ENDS
PUBLIC	__real@c0000000
PUBLIC	__real@bf800000
PUBLIC	?CreateCube@Mesh@@QAEXXZ			; Mesh::CreateCube
;	COMDAT __real@c0000000
CONST	SEGMENT
__real@c0000000 DD 0c0000000r			; -2
CONST	ENDS
;	COMDAT __real@bf800000
CONST	SEGMENT
__real@bf800000 DD 0bf800000r			; -1
; Function compile flags: /Ogspy
CONST	ENDS
compile	SEGMENT
$T18010 = -16						; size = 16
$T18009 = -16						; size = 16
$T18008 = -16						; size = 16
$T18007 = -16						; size = 16
?CreateCube@Mesh@@QAEXXZ PROC				; Mesh::CreateCube
; _this$ = ecx

; 408  : {

	push	ebp
	mov	ebp, esp
	and	esp, -16				; fffffff0H
	sub	esp, 20					; 00000014H
	push	ebx
	push	esi
	push	edi
	mov	ebx, ecx

; 409  : 	Lock();

	call	?Lock@Mesh@@QAEXXZ			; Mesh::Lock

; 410  : 	VertexBuffer[0].Position = vec4(-2, -1, 0, 1);

	fld1
	sub	esp, 16					; 00000010H
	fstp	DWORD PTR [esp+12]
	fldz
	lea	ecx, DWORD PTR $T18007[esp+48]
	fstp	DWORD PTR [esp+8]
	fld	DWORD PTR __real@bf800000
	fstp	DWORD PTR [esp+4]
	fld	DWORD PTR __real@c0000000
	fstp	DWORD PTR [esp]
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4

; 411  : 	VertexBuffer[1].Position = vec4(-2, 1, 0, 1);

	fld1
	mov	edi, DWORD PTR [ebx+12]
	mov	esi, eax
	movsd
	sub	esp, 16					; 00000010H
	movsd
	fst	DWORD PTR [esp+12]
	fldz
	fstp	DWORD PTR [esp+8]
	movsd
	fstp	DWORD PTR [esp+4]
	fld	DWORD PTR __real@c0000000
	lea	ecx, DWORD PTR $T18008[esp+48]
	fstp	DWORD PTR [esp]
	movsd
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4
	mov	edi, DWORD PTR [ebx+12]

; 412  : 	VertexBuffer[2].Position = vec4(2, 1, 0, 1);

	fld1
	add	edi, 32					; 00000020H
	mov	esi, eax
	movsd
	sub	esp, 16					; 00000010H
	movsd
	fst	DWORD PTR [esp+12]
	fldz
	fstp	DWORD PTR [esp+8]
	movsd
	fstp	DWORD PTR [esp+4]
	fld	DWORD PTR __real@40000000
	lea	ecx, DWORD PTR $T18009[esp+48]
	fstp	DWORD PTR [esp]
	movsd
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4
	mov	edi, DWORD PTR [ebx+12]

; 413  : 	VertexBuffer[3].Position = vec4(2, -1, 0, 1);

	fld1
	add	edi, 64					; 00000040H
	mov	esi, eax
	movsd
	sub	esp, 16					; 00000010H
	movsd
	fstp	DWORD PTR [esp+12]
	fldz
	fstp	DWORD PTR [esp+8]
	movsd
	fld	DWORD PTR __real@bf800000
	fstp	DWORD PTR [esp+4]
	fld	DWORD PTR __real@40000000
	lea	ecx, DWORD PTR $T18010[esp+48]
	fstp	DWORD PTR [esp]
	movsd
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4
	mov	edi, DWORD PTR [ebx+12]
	add	edi, 96					; 00000060H
	mov	esi, eax
	movsd
	movsd
	movsd
	movsd

; 414  : 	VertexCount = 4;
; 415  : 	IndexBuffer[0] = 4;

	mov	ecx, DWORD PTR [ebx+16]
	push	4
	pop	eax
	mov	DWORD PTR [ebx], eax
	mov	WORD PTR [ecx], ax

; 416  : 	IndexBuffer[1] = 0;

	mov	eax, DWORD PTR [ebx+16]

; 417  : 	IndexBuffer[2] = 1;
; 418  : 	IndexBuffer[3] = 2;
; 419  : 	IndexBuffer[4] = 3;
; 420  : 	IndexCount = 5;
; 421  : 	FaceCount = 1;
; 422  : 	Extrude(1.0f);

	fld1
	xor	ecx, ecx
	mov	WORD PTR [eax+2], cx
	mov	ecx, DWORD PTR [ebx+16]
	xor	eax, eax
	inc	eax
	push	2
	mov	edx, eax
	mov	WORD PTR [ecx+4], dx
	mov	ecx, DWORD PTR [ebx+16]
	pop	edx
	mov	WORD PTR [ecx+6], dx
	mov	ecx, DWORD PTR [ebx+16]
	push	3
	pop	edx
	mov	WORD PTR [ecx+8], dx
	push	ecx
	mov	ecx, ebx
	fstp	DWORD PTR [esp]
	mov	DWORD PTR [ebx+4], 5
	mov	DWORD PTR [ebx+8], eax
	call	?Extrude@Mesh@@AAEXM@Z			; Mesh::Extrude

; 423  : 	GenerateNormals();

	mov	ecx, ebx
	call	?GenerateNormals@Mesh@@AAEXXZ		; Mesh::GenerateNormals

; 424  : 	Triangulate();

	mov	ecx, ebx
	call	?Triangulate@Mesh@@AAEXXZ		; Mesh::Triangulate

; 425  : 	Homogenize();

	mov	ecx, ebx
	call	?Homogenize@Mesh@@AAEXXZ		; Mesh::Homogenize

; 426  : 	Unlock();

	call	?Unlock@Mesh@@QAEXXZ			; Mesh::Unlock

; 427  : }

	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	0
?CreateCube@Mesh@@QAEXXZ ENDP				; Mesh::CreateCube
compile	ENDS
PUBLIC	?CreateSphere@Mesh@@QAEXI@Z			; Mesh::CreateSphere
; Function compile flags: /Ogspy
compile	SEGMENT
$T18018 = -16						; size = 16
$T18017 = -16						; size = 16
$T18016 = -16						; size = 16
$T18015 = -16						; size = 16
_lod$ = 8						; size = 4
?CreateSphere@Mesh@@QAEXI@Z PROC			; Mesh::CreateSphere
; _this$ = ecx

; 431  : {

	push	ebp
	mov	ebp, esp
	and	esp, -16				; fffffff0H
	sub	esp, 20					; 00000014H
	push	ebx
	push	esi
	push	edi
	mov	ebx, ecx

; 432  : 	Lock();

	call	?Lock@Mesh@@QAEXXZ			; Mesh::Lock

; 433  : 	VertexBuffer[0].Position = vec4(-1, -1, 0, 1);

	fld1
	sub	esp, 16					; 00000010H
	fstp	DWORD PTR [esp+12]
	fldz
	lea	ecx, DWORD PTR $T18015[esp+48]
	fstp	DWORD PTR [esp+8]
	fld	DWORD PTR __real@bf800000
	fst	DWORD PTR [esp+4]
	fstp	DWORD PTR [esp]
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4

; 434  : 	VertexBuffer[1].Position = vec4(-1, 1, 0, 1);

	fld1
	mov	edi, DWORD PTR [ebx+12]
	mov	esi, eax
	movsd
	sub	esp, 16					; 00000010H
	movsd
	fst	DWORD PTR [esp+12]
	fldz
	fstp	DWORD PTR [esp+8]
	movsd
	fstp	DWORD PTR [esp+4]
	fld	DWORD PTR __real@bf800000
	lea	ecx, DWORD PTR $T18016[esp+48]
	fstp	DWORD PTR [esp]
	movsd
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4
	mov	edi, DWORD PTR [ebx+12]

; 435  : 	VertexBuffer[2].Position = vec4(1, 1, 0, 1);

	fld1
	add	edi, 32					; 00000020H
	mov	esi, eax
	movsd
	sub	esp, 16					; 00000010H
	movsd
	fst	DWORD PTR [esp+12]
	fldz
	fstp	DWORD PTR [esp+8]
	movsd
	fst	DWORD PTR [esp+4]
	lea	ecx, DWORD PTR $T18017[esp+48]
	fstp	DWORD PTR [esp]
	movsd
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4
	mov	edi, DWORD PTR [ebx+12]

; 436  : 	VertexBuffer[3].Position = vec4(1, -1, 0, 1);

	fld1
	add	edi, 64					; 00000040H
	mov	esi, eax
	movsd
	sub	esp, 16					; 00000010H
	movsd
	fst	DWORD PTR [esp+12]
	fldz
	fstp	DWORD PTR [esp+8]
	movsd
	fld	DWORD PTR __real@bf800000
	fstp	DWORD PTR [esp+4]
	lea	ecx, DWORD PTR $T18018[esp+48]
	fstp	DWORD PTR [esp]
	movsd
	call	??0vec4@@QAE@MMMM@Z			; vec4::vec4
	mov	edi, DWORD PTR [ebx+12]
	add	edi, 96					; 00000060H
	mov	esi, eax
	movsd
	movsd
	movsd
	movsd

; 437  : 	VertexCount = 4;
; 438  : 	IndexBuffer[0] = 4;

	mov	ecx, DWORD PTR [ebx+16]
	push	4
	pop	eax
	mov	DWORD PTR [ebx], eax
	mov	WORD PTR [ecx], ax

; 439  : 	IndexBuffer[1] = 0;

	mov	eax, DWORD PTR [ebx+16]
	xor	ecx, ecx
	mov	WORD PTR [eax+2], cx

; 440  : 	IndexBuffer[2] = 1;

	mov	ecx, DWORD PTR [ebx+16]

; 441  : 	IndexBuffer[3] = 2;
; 442  : 	IndexBuffer[4] = 3;
; 443  : 	IndexCount = 5;
; 444  : 	FaceCount = 1;
; 445  : 	Extrude(1.0f);

	fld1
	xor	eax, eax
	inc	eax
	push	2
	mov	edx, eax
	mov	WORD PTR [ecx+4], dx
	mov	ecx, DWORD PTR [ebx+16]
	pop	edx
	mov	WORD PTR [ecx+6], dx
	mov	ecx, DWORD PTR [ebx+16]
	push	3
	pop	edx
	mov	WORD PTR [ecx+8], dx
	push	ecx
	mov	ecx, ebx
	fstp	DWORD PTR [esp]
	mov	DWORD PTR [ebx+4], 5
	mov	DWORD PTR [ebx+8], eax
	call	?Extrude@Mesh@@AAEXM@Z			; Mesh::Extrude

; 446  : 	for (unsigned int i = 0; i < lod; ++i)

	mov	esi, DWORD PTR _lod$[ebp]
	test	esi, esi
	je	SHORT $LN1@CreateSphe
$LL3@CreateSphe:

; 447  : 		CatmullClarkSubdivide();

	mov	ecx, ebx
	call	?CatmullClarkSubdivide@Mesh@@AAEXXZ	; Mesh::CatmullClarkSubdivide
	dec	esi
	jne	SHORT $LL3@CreateSphe
$LN1@CreateSphe:

; 448  : 	GenerateNormals();

	mov	ecx, ebx
	call	?GenerateNormals@Mesh@@AAEXXZ		; Mesh::GenerateNormals

; 449  : 	Triangulate();

	mov	ecx, ebx
	call	?Triangulate@Mesh@@AAEXXZ		; Mesh::Triangulate

; 450  : 	Homogenize();

	mov	ecx, ebx
	call	?Homogenize@Mesh@@AAEXXZ		; Mesh::Homogenize

; 451  : 	Unlock();

	call	?Unlock@Mesh@@QAEXXZ			; Mesh::Unlock

; 452  : }

	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	4
?CreateSphere@Mesh@@QAEXI@Z ENDP			; Mesh::CreateSphere
compile	ENDS
PUBLIC	??0Mesh@@QAE@XZ					; Mesh::Mesh
; Function compile flags: /Ogspy
compile	SEGMENT
??0Mesh@@QAE@XZ PROC					; Mesh::Mesh
; _this$ = ecx

; 7    : {

	push	ebx
	push	ebp
	push	esi
	mov	esi, ecx
	xor	ebp, ebp
	push	edi
	lea	ecx, DWORD PTR [esi+32]
	mov	DWORD PTR [esi], ebp
	mov	DWORD PTR [esi+4], ebp
	call	??0OpInfo@Mesh@@QAE@XZ

; 8    : 	glGenVertexArrays(1, &VertexArrayObject);	

	lea	edi, DWORD PTR [esi+4751408]
	push	edi
	push	1
	call	DWORD PTR ?glGenVertexArrays@@3P6GXHPAI@ZA ; glGenVertexArrays

; 9    : 	glBindVertexArray(VertexArrayObject);

	push	DWORD PTR [edi]
	call	DWORD PTR ?glBindVertexArray@@3P6GXI@ZA	; glBindVertexArray

; 10   : 
; 11   : 	glGenBuffers(1, &VertexArrayBuffer);

	lea	edi, DWORD PTR [esi+4751412]
	push	edi
	push	1
	call	DWORD PTR ?glGenBuffers@@3P6GXHPAI@ZA	; glGenBuffers

; 12   : 	glBindBuffer(GL_ARRAY_BUFFER, VertexArrayBuffer);

	push	DWORD PTR [edi]
	mov	edi, 34962				; 00008892H
	push	edi
	call	DWORD PTR ?glBindBuffer@@3P6GXII@ZA	; glBindBuffer

; 13   : 	glBufferData(GL_ARRAY_BUFFER, MaxVertexBuffer * sizeof(MeshVertex), 0, GL_STATIC_DRAW);

	lea	ebx, DWORD PTR [edi+82]
	push	ebx
	push	ebp
	push	ebp
	push	2097152					; 00200000H
	push	edi
	call	DWORD PTR ?glBufferData@@3P6GXI_JPBXI@ZA ; glBufferData

; 14   : 
; 15   : 	glGenBuffers(1, &IndexBufferObject);

	lea	edi, DWORD PTR [esi+4751416]
	push	edi
	push	1
	call	DWORD PTR ?glGenBuffers@@3P6GXHPAI@ZA	; glGenBuffers

; 16   : 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBufferObject);

	push	DWORD PTR [edi]
	lea	edi, DWORD PTR [ebx-81]
	push	edi
	call	DWORD PTR ?glBindBuffer@@3P6GXII@ZA	; glBindBuffer

; 17   : 	glBufferData(GL_ELEMENT_ARRAY_BUFFER, MaxIndexBuffer * sizeof(unsigned short), NULL, GL_STATIC_DRAW);

	push	ebx
	push	ebp
	push	ebp
	push	589824					; 00090000H
	push	edi
	call	DWORD PTR ?glBufferData@@3P6GXI_JPBXI@ZA ; glBufferData

; 18   : 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

	push	ebp
	push	edi
	call	DWORD PTR ?glBindBuffer@@3P6GXII@ZA	; glBindBuffer

; 19   : 	glBindVertexArray(0);

	push	ebp
	call	DWORD PTR ?glBindVertexArray@@3P6GXI@ZA	; glBindVertexArray
	pop	edi

; 20   : }

	mov	eax, esi
	pop	esi
	pop	ebp
	pop	ebx
	ret	0
??0Mesh@@QAE@XZ ENDP					; Mesh::Mesh
compile	ENDS
END