Mulscale - Revision history

Fox at 20:09, 14 November 2019

2019-11-14T20:09:04Z

← Older revision		Revision as of 13:09, 14 November 2019
Line 15:		Line 15:
	sin ''Sine'' sprite[].ang		sin ''Sine'' sprite[].ang
	'''mulscale''' ''Result'' ''Length'' ''Sine'' 14		'''mulscale''' ''Result'' ''Length'' ''Sine'' 14

			See also [[divscale]] and [[scalevar]].

	[[Category:EDuke32 specific commands]]		[[Category:EDuke32 specific commands]]
	[[Category:Gamevar manipulation]]		[[Category:Gamevar manipulation]]

Fox at 19:48, 14 November 2019

2019-11-14T19:48:33Z

← Older revision		Revision as of 12:48, 14 November 2019
Line 11:		Line 11:
	The main difference is that the calculation uses 64 bits to prevent overflow, while using gamevars for intermediate values would limit it to 31 bits.		The main difference is that the calculation uses 64 bits to prevent overflow, while using gamevars for intermediate values would limit it to 31 bits.

	~~One~~ example ~~of where this limitation takes places is with~~ [[~~rotatesprite~~]] ~~scaling, where 320*65536 scaled with~~ [[~~statusbarscale~~]] ~~is dangerously close~~ to ~~31 bits~~.		For example, [[sin]] or [[cos]] use a scaling factor of 1:16384, corresponding to a 14 bit shift. So if you wanted to scale the result with a certain length, you would do:

	~~Another example is how the trigonometric commands [[~~sin]] and [[cos]] use a fixed-point fractional scaling factor of 1:16384, corresponding to a 14 bit shift. So, if you wanted to multiply some ''length'' by the cosine of the current sprite's angle, you could write:		sin ''Sine'' sprite[].ang
			'''mulscale''' ''Result'' ''Length'' ''Sine'' 14
	~~cos~~ ''~~cosang~~'' sprite[].ang
	'''mulscale''' ''~~result~~'' ''~~length~~'' ''~~cosang~~'' 14

	[[Category:EDuke32 specific commands]]		[[Category:EDuke32 specific commands]]
	[[Category:Gamevar manipulation]]		[[Category:Gamevar manipulation]]

Fox: Fox moved page Mulscale, Divscale and Scalevar to Mulscale over redirect: Undo

2019-11-14T19:25:10Z

Fox moved page Mulscale, Divscale and Scalevar to Mulscale over redirect: Undo

← Older revision		Revision as of 12:25, 14 November 2019
(No difference)

Fox: Fox moved page Mulscale to Mulscale, Divscale and Scalevar

2019-11-14T19:19:51Z

Fox moved page Mulscale to Mulscale, Divscale and Scalevar

← Older revision		Revision as of 12:19, 14 November 2019
(No difference)

Hendricks266 at 03:23, 14 November 2019

2019-11-14T03:23:47Z

← Older revision		Revision as of 20:23, 13 November 2019
Line 1:		Line 1:
	'''mulscale''' <Result> <~~Value~~ 1> <~~Value~~ 2> <~~Value 3~~>		'''mulscale''' <Result> <Factor 1> <Factor 2> <Right Shift>

	~~Equals~~ the ~~following series of commands:~~		In C terms, this command performs roughly the expression <code><Result> = (<Factor 1> * <Factor 2>) >> <Right Shift></code>.

	set <Result> <~~Value~~ 1>		In CON terms, it is very similar to the following series of commands:
	mul <Result> <~~Value~~ 2>
	shiftr <Result> <~~Value 3~~>		set <Result> <Factor 1>
			mul <Result> <Factor 2>
			shiftr <Result> <Right Shift>

	The main difference is that the calculation uses 64 bits to prevent overflow, while using gamevars for intermediate values would limit it to 31 bits.		The main difference is that the calculation uses 64 bits to prevent overflow, while using gamevars for intermediate values would limit it to 31 bits.

	One example of where this limitation takes places is with rotatesprite scaling, where 320*65536 scaled with [[statusbarscale]] is dangerously close to 31 bits.		One example of where this limitation takes places is with [[rotatesprite]] scaling, where 320*65536 scaled with [[statusbarscale]] is dangerously close to 31 bits.

			Another example is how the trigonometric commands [[sin]] and [[cos]] use a fixed-point fractional scaling factor of 1:16384, corresponding to a 14 bit shift. So, if you wanted to multiply some ''length'' by the cosine of the current sprite's angle, you could write:

			cos ''cosang'' sprite[].ang
			'''mulscale''' ''result'' ''length'' ''cosang'' 14

	[[Category:EDuke32 specific commands]]		[[Category:EDuke32 specific commands]]
	[[Category:Gamevar manipulation]]		[[Category:Gamevar manipulation]]

Fox: Wow, much complicated

2019-11-10T15:56:48Z

Wow, much complicated

← Older revision		Revision as of 08:56, 10 November 2019
Line 1:		Line 1:
	'''mulscale''' ''<~~res~~>'' <~~eax~~> <~~edx~~> <~~ecx~~>		'''mulscale''' <Result> <Value 1> <Value 2> <Value 3>

	~~The formula is<br/>~~		Equals the following series of commands:
	~~res=(eax*edx)>>ecx~~

	~~The intermediate value is computed using 64 bits to prevent overflow and the result is 32 bits wide.~~		set <Result> <Value 1>
	~~This is a math function which is implemented in assembler programing language because it makes the calculation faster.~~		mul <Result> <Value 2>
			shiftr <Result> <Value 3>

	The ~~primary use of this function~~ is ~~in calculations involving scaled integers, that is, integers~~ that ~~have a binary point somewhere by convention. For example,~~ the ~~trigonometric functions [[Sin]] and [[Cos]] use a scaling of 1:16384~~, ~~corresponding~~ to ~~a 14 bit shift~~. ~~So, if you wanted to multiply some length (say, ''dx'') by a cosine value (say, ''cosang''), you could write~~		The main difference is that the calculation uses 64 bits to prevent overflow, while using gamevars for intermediate values would limit it to 31 bits.

	~~'''mulscale''' ''dx'' ''dx'' ''cosang'' 14~~

			One example of where this limitation takes places is with rotatesprite scaling, where 320*65536 scaled with [[statusbarscale]] is dangerously close to 31 bits.

	[[Category:EDuke32 specific commands]]		[[Category:EDuke32 specific commands]]
	[[Category:Gamevar manipulation]]		[[Category:Gamevar manipulation]]

Helixhorned: fix my example.

2012-04-21T18:27:55Z

fix my example.

← Older revision		Revision as of 11:27, 21 April 2012
Line 9:		Line 9:
	The primary use of this function is in calculations involving scaled integers, that is, integers that have a binary point somewhere by convention. For example, the trigonometric functions [[Sin]] and [[Cos]] use a scaling of 1:16384, corresponding to a 14 bit shift. So, if you wanted to multiply some length (say, ''dx'') by a cosine value (say, ''cosang''), you could write		The primary use of this function is in calculations involving scaled integers, that is, integers that have a binary point somewhere by convention. For example, the trigonometric functions [[Sin]] and [[Cos]] use a scaling of 1:16384, corresponding to a 14 bit shift. So, if you wanted to multiply some length (say, ''dx'') by a cosine value (say, ''cosang''), you could write

	'''mulscale''' ''dx'' ''cosang'' 14		'''mulscale''' ''dx'' ''dx'' ''cosang'' 14


	[[Category:EDuke32 specific commands]]		[[Category:EDuke32 specific commands]]
	[[Category:Gamevar manipulation]]		[[Category:Gamevar manipulation]]

Helixhorned: extended this a bit

2010-08-04T14:27:35Z

extended this a bit

← Older revision		Revision as of 07:27, 4 August 2010
Line 1:		Line 1:
	'''mulscale''' <res> <eax> <edx> <ecx>		'''mulscale''' ''<res>'' <eax> <edx> <ecx>

	The formula is<br/>		The formula is<br/>
	res=(eax*edx)>>ecx		res=(eax*edx)>>ecx

			The intermediate value is computed using 64 bits to prevent overflow and the result is 32 bits wide.
	This is a math function which is implemented in assembler programing language because it makes the calculation faster.		This is a math function which is implemented in assembler programing language because it makes the calculation faster.

			The primary use of this function is in calculations involving scaled integers, that is, integers that have a binary point somewhere by convention. For example, the trigonometric functions [[Sin]] and [[Cos]] use a scaling of 1:16384, corresponding to a 14 bit shift. So, if you wanted to multiply some length (say, ''dx'') by a cosine value (say, ''cosang''), you could write

			'''mulscale''' ''dx'' ''cosang'' 14


	[[Category:EDuke32 specific commands]]		[[Category:EDuke32 specific commands]]
	[[Category:Gamevar manipulation]]		[[Category:Gamevar manipulation]]

One at 20:07, 4 May 2009

2009-05-04T20:07:00Z

← Older revision		Revision as of 13:07, 4 May 2009
Line 1:		Line 1:
	mulscale <res> <eax> <edx> <ecx>		'''mulscale''' <res> <eax> <edx> <ecx>

	The formula is<br/>		The formula is<br/>

XTHX2 at 11:21, 1 August 2008

2008-08-01T11:21:36Z

← Older revision		Revision as of 04:21, 1 August 2008
Line 4:		Line 4:
	res=(eax*edx)>>ecx		res=(eax*edx)>>ecx

	This is a math function which is implemented in assembler programing language because it ~~make~~ the calculation faster.		This is a math function which is implemented in assembler programing language because it makes the calculation faster.

	[[Category:EDuke32 specific commands]]		[[Category:EDuke32 specific commands]]
	[[Category:Gamevar manipulation]]		[[Category:Gamevar manipulation]]