1
Yabasic / Re: Another Colour Select/Randomizer
« on: May 04, 2018 »
Not bad
Show Posts
This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.
3
Other languages / Re: QBASIC demoscene?
« on: September 21, 2016 »
Sorry for the late response but there used to be plenty of QBasic code available all over the net, many of the sites have faded away but a few can still be found. Heres a good place to start
http://www.phatcode.net/downloads.php?sub=demos
http://www.phatcode.net/downloads.php?sub=demos
4
C / C++ /C# / Re: C++ Win32 - Draw directly into memory and show Bitmap
« on: August 27, 2015 »
Something like this should work, I haven't compiled it but this set of calls is what I use to push pixels with pure GDI.
Code: [Select]
#define ResX 256
#define ResY 192
int main(void) {
// required data
static int pixel[ResX*ResY];
static BITMAPINFO bmi = {sizeof(BITMAPINFOHEADER),ResX,ResY,1,32};
// window creation
HWND hWnd = CreateWindowExA(0,"edit",0,WS_POPUP|WS_VISIBLE|WS_MAXIMIZE,0,0,0,0,0,0,0,0);
HDC hDC = GetDC(hWnd);
ShowCursor(FALSE);
// main loop
for (MSG msg; msg.message != WM_KEYDOWN; PeekMessage(&msg,0,0,0,PM_REMOVE)) {
// screen blitting
int ScreenX = GetSystemMetrics(SM_CXSCREEN);
int ScreenY = GetSystemMetrics(SM_CYSCREEN);
StretchDIBits(hDC,0,0,ScreenX,ScreenY,0,0,ResX,ResY,pixel,&bmi,0,SRCCOPY);
SwapBuffers(hDC);
// pixel pushing
int t = GetTickCount();
for (int i = 0; i < ResX*ResY; i++) pixel[i] = i + t;
}
ExitProcess(0);
return 0;
}
5
C / C++ /C# / Floating Point Hacks
« on: October 05, 2014 »
Here are some nifty bithacks for the IEEE floating point format
The infamous Quakes fast inverse square root...
Approximate square root (software solution is faster than hardware)
Newton raphson
Obviously this one simply flips the sign bit
Log2 can be done in a similar fashion
Exponent2 as well
Faster fmod1
The infamous Quakes fast inverse square root...
Code: [Select]
float invSqrt(float x)
{
float xhalf = 0.5f*x;
union
{
float x;
int i;
} u;
u.x = x;
u.i = 0x5f3759df - (u.i >> 1);
/* The next line can be repeated any number of times to increase accuracy */
u.x = u.x * (1.5f - xhalf * u.x * u.x);
return u.x;
}
// Quakes version
float Q_rsqrt( float number )
{
int i;
float x2, y;
const float threehalfs = 1.5f;
x2 = number * 0.5f;
y = number;
i = *( int* )&y; // evil floating point bit level hacking
i = 0x5F3759DF - ( i >> 1 ); // what the f***?
y = *( float* )&i;
y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
// y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed
return y;
}
// Lomonts version
float InvSqrt( float x )
{
float xhalf = 0.5f*x;
int i = *( int* )&x; // get bits for floating value
i = 0x5F375A86 - ( i >> 1 ); // gives initial guess y0
x = *( float* )&i; // convert bits back to float
x = x*(1.5f - xhalf*x*x ); // Newton step, repeating increases accuracy
return x;
}
rsqrt:
_asm {
rsqrtps xmm0, xmmword ptr [ rcx ] ;
movaps xmmword ptr [ rcx ], xmm0 ;
ret ;
}
sqrthw:
_asm {
rsqrtps xmm0, xmmword ptr [ rcx ] ;
rcpps xmm0, xmm0 ;
movaps xmmword ptr [ rcx ], xmm0 ;
ret ;
}
Approximate square root (software solution is faster than hardware)
Code: [Select]
float fastsqrt( float n )
{
int i = *( int* )&n;
i -= 1 << 23;
i >>= 1;
i += 1 << 29;
return *( float* )&i;
}
Newton raphson
Code: [Select]
float sqrtNewRapf( float x )
{
float y = sqrtf( x ); // Get approx
// y = ( y*y + x ) / ( 2*y ); // Newton-Raphson as many times as needed
return ( y*y + x ) / ( 2*y );
}
OneAsIntShr1 dd 4 dup ( 0x1FC00000 ) ; OneAsInt >> 1
fastsqrt:
_asm {
movdqa xmm0, xmmword ptr [ rcx ] ;
psrld xmm0, 1 ;
paddd xmm0, xmmword ptr [ OneAsIntShr1 ] ;
movdqa xmmword ptr [ rcx ], xmm0 ;
ret ;
}
OneAsIntShr1 dd 4 dup ( 0x1FC00000 ) ; OneAsInt >> 1
fastsqrt:
_asm {
movdqa xmm0, xmmword ptr [ rcx ] ;
psrld xmm0, 1 ;
paddd xmm0, xmmword ptr [ OneAsIntShr1 ] ;
; Newton Raphson
movaps xmm1, xmm0 ; Place y ( our guess ) into xmm1 for doubling
addps xmm1, xmm1 ; double y
mulps xmm0, xmm0 ; square y
addps xmm0, xmmword ptr [ rcx ] ; add original x
rcpps xmm1, xmm1 ; Divide by our 2y
mulps xmm0, xmm1 ;
movaps xmmword ptr [ rcx ], xmm0 ; Store result
ret ;
}
Obviously this one simply flips the sign bit
Code: [Select]
_inline float neg( float f )
{
return AsFloat( AsInt( f ) ^ 0x80000000 );
}
fneg:
_asm {
pcmpeqd xmm1, xmm1 ; Get 0x80000000, -0.0 int xmm1
pslld xmm1, 31 ;
; loop here down as necessary ;
movdqa xmm0, xmmword ptr [ rcx ] ;
pxor xmm0, xmm1 ;
movdqa xmmword ptr [ rcx ], xmm0 ;
ret ;
}
Log2 can be done in a similar fashion
Code: [Select]
const unsigned int OneAsInt = 0x3F800000; // 1.0f as int
const float ScaleUp = float( 0x00800000 ); // 8388608.0, 2^23
const float ScaleDown = 1.0f / ScaleUp;
float Log2( float x )
{
return float ( AsInt( x )-OneAsInt )*ScaleDown;
}
OneAsInt dd 4 dup ( 0x3F800000 ) ; 1.0 bit pattern as int
ScaleDown dd 4 dup ( 0x34000000 ) ; 4 copies of 1.0 / ScaleUp
Log2f:
asm {
movdqa xmm0, xmmword ptr [ rcx ] ;
psubd xmm0, xmmword ptr [ OneAsInt ] ;
cvtdq2ps xmm0, xmm0 ; cast to singles
mulps xmm0, xmmword ptr [ ScaleDown ] ;
movdqa xmmword ptr [ rcx ], xmm0 ;
ret ;
}
Exponent2 as well
Code: [Select]
float Exp2( float x )
{
return AsFloat( int( x*ScaleUp ) + OneAsInt );
}
OneAsInt dd 4 dup ( 0x3F800000 ) ; 1.0 bit pattern as int
Pow2f:
_asm {
movdqa xmm0, xmmword ptr [ rcx ] ;
movaps xmm1, xmmword ptr [ rdx ] ;
psubd xmm0, xmmword ptr [ OneAsInt ] ;
cvtdq2ps xmm0, xmm0 ;
mulps xmm0, xmm1 ;
cvtps2dq xmm0, xmm0 ;
paddd xmm0, xmmword ptr [ OneAsInt ] ;
movaps xmmword ptr [ rcx ], xmm0 ;
ret ;
}
Faster fmod1
Code: [Select]
#include <math.h>
#include <time.h>
#include <stdio.h>
static volatile float f2 = 0.0f;
float fmod1_fast( const float f )
{
const int iBits = *( reinterpret_cast< const int* >( &f ) );
// extract exponent
const int iExponent = ( ( iBits & 0x7F800000 ) - 0x3F800000 ) >> 23;
if( iExponent > 23 )
{
return 0.0f;
}
if( iExponent < 0 )
{
return f;
}
const int iSignificand = iBits & 0x007FFFFF;
if( iSignificand == 0 )
{
return 0.0f;
}
// find the most significant bit of the significand - this can be done by binary search
/*
0111 1111 1111 1111 1111 1111
0111 1111 1111 0000 0000 0000
7 F F 0 0 0
0111 1100 0000 1111 1100 0000
7 C 0 F C 0
0110 0011 1000 1110 0011 1000
A 3 8 E 3 8
0001 0010 0100 1001 0010 0100
1 2 4 9 2 4
0100 1001 0010 0100 1001 0010
4 9 2 4 9 2
*/
int iMSB = ( iSignificand & 0x007FF000 ) ? 11 : 0;
iMSB += ( iSignificand & 0x007C0FC0 ) ? 6 : 0;
iMSB += ( iSignificand & 0x00A38E38 ) ? 3 : 0;
iMSB += ( iSignificand & 0x00124924 ) ? 2 : 0;
iMSB += ( iSignificand & 0x00492492 ) ? 1 : 0;
iMSB = 23 - iMSB;
const int iNewBits = ( ( iSignificand << ( iMSB + iExponent ) ) & 0x007FFFFF ) | ( 0x3F800000 - ( ( ( iMSB ) - iExponent ) << 23 ) );
const float fPreMod = *reinterpret_cast< const float* >( &iNewBits );
const float fMod = ( ( iBits & 0x80000000 ) ? ( 1.0f - fPreMod ) : fPreMod ) - static_cast< float > ( 1 << ( iExponent ) );
const int iNewNewBits = *reinterpret_cast< const int* >( &fMod );
const int iNewNewNewBits = iNewNewBits - ( ( iExponent << 23 ) & 0x3F800000 );
const float fMaybeSignFlippedMod = *reinterpret_cast< const float* >( &iNewNewNewBits );
return ( fMaybeSignFlippedMod > 0.0f ) ? fMaybeSignFlippedMod : ( 1.0f - -fMaybeSignFlippedMod );
}
6
C / C++ /C# / Re: VS2013 Express Win32 Project - Compilererror when using Win32 API calls
« on: August 23, 2014 »
You can use WinMainCRTStartup without using the NODEFAULTLIB switch. This will allow you to use the intrinsic functions ( such as memset ) without pulling in the entire CRT. But you will have to be extremely careful that the only CRT functions you use are intrinsics. This will also allow you to use a limited set of floating point functions.
7
Projects / Re: [IN PROGRESS] 512b GDI FrameWork
« on: August 09, 2014 »
The versions above were the product of an incremental improvement. I crunched things as far as I could, but sometimes I would start fresh and by taking a different route from the start I managed to shave additional bytes. The latest version is 295 bytes and compatible with XP, Vista, 7 and 8. But the latest version is not ( or at least should not be ) NX bit safe.
Check the first post to grab a copy of the 295 byte version.
In the source code you will find a bitfield that disects tinype at a bit level. It states explicity which bits must be 0, must be 1 or can be toggled freely ( within limits ). This bitfield was built up using a program I wrote that toggled each bit and loaded the resultant image with CreateProcess then tested for errors during CreateProcess or errors in the return value. Then I ran this program on as many PC's as I had access to which included multiple XP systems, one Vista box, multiple Windows 7 systems and just one Windows 8 system.
This bitfield was what I started from when I built the 295 byte version.
Check the first post to grab a copy of the 295 byte version.
In the source code you will find a bitfield that disects tinype at a bit level. It states explicity which bits must be 0, must be 1 or can be toggled freely ( within limits ). This bitfield was built up using a program I wrote that toggled each bit and loaded the resultant image with CreateProcess then tested for errors during CreateProcess or errors in the return value. Then I ran this program on as many PC's as I had access to which included multiple XP systems, one Vista box, multiple Windows 7 systems and just one Windows 8 system.
This bitfield was what I started from when I built the 295 byte version.
9
ASM / Re: VGA Floor Casting
« on: May 26, 2014 »
Thanks staticgerbil but I think baudsurfer just blew it away 
Very cool demo baud, but it only runs every other time. ( Maybe cx is decrementing to zero too quickly ) but when it runs it looks amazing.
Very cool demo baud, but it only runs every other time. ( Maybe cx is decrementing to zero too quickly ) but when it runs it looks amazing.
10
ASM / Re: New to asm!
« on: March 30, 2014 »I have been relearning 6502 assembly after 35 years. How much harder is x86?
Not harder just different. But for 32 bit x86 you must also learn the OS ( Win32 API, or Unix ) so this will slow you down.
It may be easier to learn x86 under DOS first and then take on Win32. Or learn Win32 from a HLL and then start learning x86.
Also iczelions tutorials are a great starting place.
11
General chat / Re: Are there people like this here?
« on: March 23, 2014 »
DrewPee maintains a Retro Computer Museum but the best forum for getting in touch with such collectors is ASSEMblergames which is a specialist meeting place for collectors of video games and modification of arcade and video games hardware.
13
ASM / Re: A 256 byte intro with music
« on: January 03, 2014 »
Works beautifully here baudsurfer!
Wonderful prod k+
Wonderful prod k+
14
General coding questions / Re: Line segment collision, rotational collision response?
« on: August 27, 2013 »
Sorry for the bad link the message I meant to link to was the first message on that page from Tetra. He shared some source code. The implementation seemed quite simple but the results where very nice.
Heres the Blitz Basic code he shared
Heres the Blitz Basic code he shared
Code: [Select]
;---rigid body.bb------------------------------------------------------------------------\
;
; rigid body
;
;
; by Tetra
;
;----------------------------------------------------------------------------------------/
AppTitle "Rigid Body Test 1.0"
SeedRnd( MilliSecs() )
;=======================================================================================|
; LOAD MODELS --|
;__Variables______________________________________
;
Type TSquare
Field x#
Field y#
Field a#
Field dx#
Field dy#
Field da#
Field odx#
Field ody#
Field oda#
Field mass#
Field velocity#
Field acceleration#
Field torque#
Field force#
Field time#
Field timePassed#
Field points#[8]
Field collided[4]
End Type
;
;------------------------------------------------
Function Load_Objects()
Local Square.TSquare
Square.TSquare = New TSquare
Square\x# = 512.0
Square\y# = 284.0
Square\a# = 20.0
Square\dx# = 0.0
Square\dy# = 0.0
Square\da# = 0.0
Square\odx# = 0.0
Square\ody# = 0.0
Square\oda# = 0.0
Square\mass# = 1.0
Square\time = MilliSecs()
End Function
;\---------------------------------------------------------------------------------------/
;=======================================================================================|
; DRAW SQUARES --|
;__Variables_____________________________________
;
;
;------------------------------------------------
Function DrawSquare()
Local Square.TSquare = First TSquare
Color 255,255,255
For i = 0 To 4 Step 2
Line Square\x# + Square\points[i],Square\y# + Square\points[i+1], Square\x# + Square\points[i+2],Square\y# + Square\points[i+3]
Next
Line Square\x# + Square\points[6],Square\y# + Square\points[7], Square\x# + Square\points[0],Square\y# + Square\points[1]
End Function
;----------------------------------------------------------------------------------------/
;=======================================================================================|
; GET ANGLE --|
;__Variables_____________________________________
;
;
; Get the angle between two vectors
;
; 0
; |
; -90 ==X== 90
; |
; 180
;------------------------------------------------
Function getAngle#( x1#,y1#, x2#,y2#, ox# = 0,oy# = 0 )
Local tvAx# = x1# - ox#
Local tvAY# = y1# - oy#
Local tvBx# = x2# - ox#
Local tvBY# = y2# - oy#
Local d# = ATan2#( tvAy#, tvAx# )
Local tvCx# = Cos#( d# ) * tvBx# + Sin#( d# ) * tvBy#
Local tvCy# = -Sin#( d# ) * tvBx# + Cos#( d# ) * tvBy#
Local newAngle# = ATan2#( tvCy#, tvCx# )
If ( newAngle# > 0.0 )
newAngle# = -(180.0 - newAngle#)
Else
newAngle# = -(-180.0 - newAngle#)
EndIf
Return newAngle#
End Function
;----------------------------------------------------------------------------------------/
;=======================================================================================|
; ANIMATE SQUARES --|
;__Variables_____________________________________
;
; g / 1s so 1pixel = 9.807 meters
Const Gravity# = 9.807 / 1000.0
;
;------------------------------------------------
Function AnimateSquare()
Local Square.TSquare = First TSquare
Local newX# = Square\x# + Square\dx#
Local newY# = Square\y# + Square\dy#
Local newA# = Square\a# + Square\da#
Local newVA# ;= Square\da#
Local bottom = 600
Local top = 100
Local leftb = 100
Local rightb = 900
Square\points[0] = 50.0 * Sin#( newA# - 45.0 )
Square\points[1] = 50.0 * Cos#( newA# - 45.0 )
Square\points[2] = 50.0 * Sin#( newA# + 45.0 )
Square\points[3] = 50.0 * Cos#( newA# + 45.0 )
Square\points[4] = 50.0 * Sin#( newA# + 135.0 )
Square\points[5] = 50.0 * Cos#( newA# + 135.0 )
Square\points[6] = 50.0 * Sin#( newA# - 135.0 )
Square\points[7] = 50.0 * Cos#( newA# - 135.0 )
;Color 0,255,0
;Line Square\x#,Square\y#, Square\x#+Square\vx#*10,Square\y#+Square\vy#*10
Local distance#, newAVel#, tempAVel#, tempXVel#, tempYVel#, impactX#, impactY#
Local reverseY = 0
Local reverseX = 0
Local Ejection#
Local angle#
tempXVel# = Square\dx#
tempYVel# = Square\dy#
Square\timePassed# = ( Float( MilliSecs() ) - Square\time# )
Square\time# = MilliSecs()
For i = 0 To 3
impactX# = Square\points[(i*2)]
impactY# = Square\points[(i*2)+1]
; this is a hack to make sure the box stays where it should do
; if it travelled as hyper speed it would fail ;)
; also the direction of the force wont simply reverse
If ( impactY# + newY# > bottom )
Ejection# = ( (impactY# + newY#) - bottom )
newY# = newY# - Ejection#
reverseY = 1
ElseIf ( impactY# + newY# < top )
Ejection# = ( top - (impactY# + newY#) )
newY# = newY# + Ejection#
reverseY = -1
EndIf
If ( impactX# + newX# >= rightb )
Ejection# = ( (impactX# + newX#) - rightb )
newX# = newX# - Ejection#
reverseX = 1
ElseIf ( impactX# + newX# < leftb )
Ejection# = ( leftb - (impactX# + newX#) )
newX# = newX# + Ejection#
reverseX = -1
EndIf
If ( reverseX <> 0 )Or( reverseY <> 0 )
;
; Force = Mass * Acceleration
; Acceleration is the rate of change in velocity over time a = v/t
;
Square\velocity# = VectorLength#( Square\dx# - Square\odx#, Square\dy# - Square\ody# )
Square\acceleration# = Square\velocity# / ( Square\timePassed# / 1000.0 )
Square\force# = Square\mass# * Square\acceleration#
;
; Angle between the direction vector and point of impact vector
;
angle# = -getAngle( impactX#,impactY#, Square\dx#, Square\dy# )
;
; torque = distance to center * Force * sin( angle )
;
distance# = VectorLength#( impactX#, impactY# )
Square\torque# = Square\force# * distance# * Sin( angle# )
;
; Convert torque to angular velocity
;
newVA# = newVA# + ( Square\torque# * 360.0 )
EndIf
Next
If reverseY = 1
tempYVel# = -Abs(Square\dy#) * 0.5
ElseIf reverseY = -1
tempYVel# = Abs(Square\dy#) * 0.5
EndIf
If reverseX = 1
tempXVel# = -Abs(Square\dx#) * 0.5
ElseIf reverseX = -1
tempXVel# = Abs(Square\dx#) * 0.5
EndIf
Square\x# = newX#
Square\y# = newY#
Square\a# = newA#
Square\odx# = Square\dx#
Square\ody# = Square\dy#
Square\dx# = tempXVel#
Square\dy# = tempYVel#
Square\da# = newVA#; * Float(Square\timePassed)
Square\dy# = Square\dy# + ( Gravity# * Square\timePassed# )
Color 128,128,128
Line leftb,bottom ,rightb,bottom
Line leftb,top ,rightb,top
Line leftb,top ,leftb,bottom
Line rightb,top ,rightb,bottom
End Function
;----------------------------------------------------------------------------------------/
;=======================================================================================|
; VECTOR LENGTH --|
;__Variables_____________________________________
;
;
;------------------------------------------------
Function VectorLength#( x#,y# )
Return Sqr#( x# * x# + y# * y# )
End Function
;----------------------------------------------------------------------------------------/
;=======================================================================================|
; READ INPUT --|
;__Variables_____________________________________
;
Global EXIT_PROGRAM = False
Global click = False
;
;------------------------------------------------
Function Read_Input()
If KeyDown(1) Then EXIT_PROGRAM = True
Local Square.TSquare = First TSquare
If MouseDown(1)
If Not click
Square\x# = 512
Square\y# = 384
Square\dx# = Rand(-100,100) / 10.0
Square\dy# = Rand(-100,100) / 10.0
Square\da# = Rand(-100,100) / 100.0
Square\a# = Rand(0,3600) / 10.0
click = True
EndIf
Else
click = False
EndIf
If MouseDown(2)
Square\x# = MouseX()
Square\y# = MouseY()
Square\dx# = MouseXSpeed()/4.0
Square\dy# = MouseYSpeed()/4.0
Square\da# = 0.0
EndIf
End Function
;----------------------------------------------------------------------------------------/
;=======================================================================================|
; INITIALIZE --|
;__Variables_____________________________________
;
Const GFX_WIDTH = 1024
Const GFX_HEIGHT = 768
Global timer
;
;------------------------------------------------
Function Initialize()
Graphics GFX_WIDTH, GFX_HEIGHT, 32, 2
timer = CreateTimer( 60 )
Load_Objects()
SetBuffer( BackBuffer() )
End Function
;----------------------------------------------------------------------------------------/
;=======================================================================================|
; MAIN --|
;__Variables_____________________________________
;
;
;------------------------------------------------
Function Main()
AnimateSquare()
DrawSquare()
Color 255,255,255
Text 10,10,"Right Click to randomize, Hold Left Click, drag then release to throw"
Local Square.TSquare = First TSquare
Text 10,30, "A Velocity: "+Square\da#
Text 10,50, "X Velocity: "+Square\dx#
Text 10,70, "Y Velocity: "+Square\dy#
End Function
;----------------------------------------------------------------------------------------/
;=======================================================================================|
; MAIN PROGRAM --|
;__Variables_____________________________________
;
;
;------------------------------------------------
Initialize()
While Not EXIT_PROGRAM
Read_Input()
Main()
Flip
Cls
WaitTimer( timer )
Wend
;----------------------------------------------------------------------------------------/
;=======================================================================================|
;-------------------------------------------------------------------------------- END --|
End
;--------------------------------------------------------------------------------------/
15
ASM / Re: Raymarching in 512 bytes
« on: August 27, 2013 »
The link should work ( tested it a moment ago )
But here is the source so you can compile using FASM
But here is the source so you can compile using FASM
Code: [Select]
format binary as 'exe'
macro tinycall proc,[arg]
{
common
if ~ arg eq
reverse
pushd arg
common
end if
call dword [ebx + proc]
}
VK_ESCAPE = (0x0000001B)
SRCCOPY = (0x00CC0020)
WS_POPUP = (0x80000000)
WS_VISIBLE = (0x10000000)
WS_MAXIMIZE = (0x01000000)
PM_REMOVE = (0x00000001)
WM_KEYDOWN = (0x00000100)
WM_KEYUP = (0x00000101)
SM_CXSCREEN = (0x00000000)
SM_CYSCREEN = (0x00000001)
RESX equ 256
RESY equ 192
ImageBase = 0x00400000
SizeOfHdr = 0x0088 ; 0x94
SizeOfCode = 0x00600080 ; 0x00040004 ; 0x00010000 + 196608 ; (196608 = 4*(RESX)*(RESY))
;GetSystemMetrics dd 0xB9DAA600
use32
root: dec ebp
pop edx
jmp jump
dd 'PE' ; .Signature
dw 0x014C ; .Machine
dw 0x0000 ; .NumberOfSections
LoadLibrary dd 0xE9826FC6 ; .TimeDateStamp
GetWindowRect dd 0xF9AC1F38 ; .PointerToSymbolTable
ShowCursor dd 0x19A434A8 ; .NumberOfSymbols
dw 0x0010 ; .SizeOfOptionalHeader
dw 0x010F ; .Characteristics (no relocations, executable, 32 bit)
Op_Hdr:
dd 0x0000010B ; .Magic .MajorLinkerVersion .MinorLinkerVersion
PeekMessage dd 0xEA1682FE ; .SizeOfCode
StretchDIBits dd 0x4ED54D5C ; .SizeOfInitializedData
ExitProcess dd 0x38A66AE8 ; .SizeOfUninitializedData
dd root ; .AddressOfEntryPoint
CreateWindowEx dd 0xF8820ECC ; .BaseOfCode
dd 'edit' ; .BaseOfData
dd ImageBase ; .ImageBase
dd 0x00000004 ; .SectionAlignment
dd 0x00000004 ; .FileAlignment
GetDC dd 0xA4D450D1 ; .MajorOperatingSystemVersion
wave dd 0x3DC90FDB ; .MinorOperatingSystemVersion .MajorImageVersion
dw 0x0004 ; .MajorSubsystemVersion
jump: push 0x30
pop ecx
push edx
jmp kern
dd SizeOfCode ; .SizeOfImage
dd SizeOfHdr ; .SizeOfHeaders
libname: dd 'gdi3' ; .CheckSum
dw 0x0002 ; .Subsystem
dw 0x0000 ; .DllCharacteristics
SizeStackClear = 0x24
NumStackValues = 0x0F
BitMapInfo = 0x68
PtrStack = (PackedStack-libname)+3
PackedStack:
db 0x08, 0x34 ; <- &edit
db 0x0A, 0x40 ; <- &edit+ImageBase
db 0x13, 0x91 ; <- window style WS_POPUP|WS_MAXIMIZE|WS_VISIBLE
db 0x60, 0x20 ; <- LOWORD(SRCCOPY);
db 0x4D, 0x01 ; <- StretchDIBits->nSrcWidth = RESX
db 0x68, 0x28 ; <- bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
db 0x56, 0x41 ; <- 41 here is compressed 00410000 == &pixel[0]
db 0x50, 0xC0 ; <- StretchDIBits->nSrcHeight = RESY
db 0x62, 0xCC ; <- HIWORD(SRCCOPY);
db 0x6D, 0x01 ; <- bmi.bmiHeader.biWidth = RESX;
dd 0x00000000 ; .NumberOfRvaAndSizes
db 0x76, 0x20 ; <- bmi.bmiHeader.biBitCount = 32;
db 0x70, 0xC0 ; <- bmi.bmiHeader.biHeight = RESY;
db 0x74, 0x01 ; <- bmi.bmiHeader.biPlanes = 1;
kern: mov eax, [fs : ecx] ; 64 8B 01
mov eax, [eax+0x0C] ; 8B 40 0C
mov eax, [eax+0x1C] ; 8B 40 1C
base: mov edx, [eax+0x20] ; 8B 50 20
mov ebp, [eax+0x08] ; 8B 68 08
cmp [edx+0x18], ch ; 38 6A 18
mov eax, [eax] ; 8B 00
jnz base ; 75 F3
mov esi, ImageBase+libname ; BE 5C 00 40 00
jmp libs ;
hash: mov ecx, [edx+0x18] ; 8B 4A 18 ; ecx = Num Exports
redo: jecxz done ; E3 2E ; ecx = 0 No More Exports
dec ecx ; 49 ; ecx = Num Exports Decreased
mov esi, [edx+0x20] ; 8B 72 20 ; edi = RVA Exports Asciiz
add esi, ebp ; 01 EE ; edi = RVA -> VA
mov esi, [esi+ecx*0x04] ; 8B 34 8E ; esi = RVA Export Asciiz Index
add esi, ebp ; 01 EE ; esi = RVA -> VA
mov ebx, 0x00000000 ; BB 00 00 00 00 ; .PointerToLinenumbers
calc: lodsb ; AC ; al = Char Export Asciiz
rol ebx, 0x06 ; C1 C3 06 ; ebx = Hash Preparation
xor bl, al ; 30 C3 ; ebx = Hash Complete
test al, al ; 84 C0 ; al = 0 Only For End of Asciiz
jnz calc ; 75 F6 ; If Not Zero Keep Hashing
cmp ebx, [edi] ; 3B 1F ; Check Hash Against Input
jnz redo ; 75 E3 ; If Not Equal Hash Next Function
mov ebx, [edx+0x24] ; 8B 5A 24 ; edi = RVA Function Ordinal
add ebx, ebp ; 01 EB ; edi = RVA -> VA
movzx ecx, word [ebx+ecx*0x02] ; 0F B7 0C 4B ;
mov ebx, [edx+0x1C] ; 8B 5A 1C ; edi = Function RVAS List
add ebx, ebp ; 01 EB ; edi = RVA -> VA
add ebp, [ebx+ecx*0x04] ; 03 2C 8B ; eax = Function RVA
mov [edi], ebp ; 89 2F
jmp done
libs: or byte [esi+0x04], cl
mov ebx, esi
mov bl, ch
scan: push 0x13 ;
pop ecx ; LoadLibrary trashes ecx
func: pusha
lea edi, [ebx+ecx*0x04]
mov eax, [ebp+0x3C] ; 8B 45 3C ; eax = RVA NT Header
mov edx, [ebp+eax+0x78] ; 8B 54 05 78 ; edx = RVA Data Directory
add edx, ebp ; 01 EA ; edx = RVA -> VA
jmp hash
done: popa ; 61 ; Restore Registers
loop func ; E2 EB
push esi ; 56
tinycall LoadLibrary ;, esi ; FF 53 0C
dec esi ; 4E
mov dword [esi], 'user' ; C7 06 75 73 65 72
xchg ebp, eax ; 95
or ebp, ebp ; 09 ED
jnz scan ; 75 DE
start: push SizeStackClear ; 0x24
pop ecx
push ebp
loop $-1
lea esi, [esi + PtrStack]
mov cl, NumStackValues
lodsw
movzx edx, al
mov [esp+edx], ah
loop $-8
lea ebp, [esp+BitMapInfo]
mov [esp+0x58], ebp
tinycall ShowCursor
tinycall CreateWindowEx
mov edx, esp
tinycall GetWindowRect, eax, edx, eax
tinycall GetDC
push eax
RESX equ 256
RESY equ 192
ResX equ ebp+0x1C
ResY equ ebp+0x20
Size equ ebp+0x1F
Pixel equ ebp+0x24
msg equ edi
pump: ;xor ecx, ecx
mov ebp, esp
tinycall PeekMessage, msg, ecx, ecx, ecx, PM_REMOVE
tinycall StretchDIBits
mov esp, ebp
mov eax, [ResX]
cmp eax, [msg + 4]
jnz main
tinycall ExitProcess
x = 0x0A
y = 0x0A
HalfResX = 0x54
HalfResY = 0x56
time = 0x78
SixtyFour = 0x3A
Sixteen = 0x18
NinetySix = 0x56
;ebx image pointer
;ebp frame pointer
;esi const pointer
;edx temp pointer
;edi pixel pointer
;ecx loop counter
main: fld dword [ebx+time]
fadd dword [ebx+wave]
fstp dword [ebx+time]
mov edi, [Pixel]
mov ecx, [Size]
draw: dec ecx
jz pump
finit
push 0x0A
pop dword [edi]
lea esi, [ebx+0x18] ;0x0010
lea edx, [ebx+0x2C] ;0x00000000
;float dirx = (float)(x+x-ResX);
;float diry = fabs((float)(y+y-ResY));
;float dirz = (float)ResX;
mov byte [edx], cl ;
fild word [edx] ;
fisub word [ebx+0x54] ; ResX/2
mov byte [edx], ch ;
fild word [edx] ;
fisub word [ebx+0x56] ; ResY/2
fabs ;
fild word [ResX] ;
;float norm = 1.0f/sqrt(dirx*dirx + diry*diry + dirz*dirz);
fld st2
fmul st0, st0
fld st2
fmul st0, st0
fld st2
fmul st0, st0
faddp st1, st0
faddp st1, st0
fsqrt
fld1
fdivrp st1, st0
;dirx *= norm;
;diry *= norm;
;dirz *= norm;
fmul st3, st0
fmul st2, st0
fmulp st1, st0
;float posx = sin(time*wave)*0x40;
;float posy = cos(time*wave)*0x10-0x20;
;float posz = 0x60;
fld dword [ebx+time]
fsincos
fimul word [ebx+0x3A] ; 0x0040
fxch
fimul word [esi]
fisub word [esi]
fisub word [esi]
fild word [ResX] ; 0x0080
cast: ;do {
;dist = fabs(posy + 0x10*sin(posx*wave)*sin(posz*wave));
fld st0
fmul dword [ebx+wave]
fsin
fld st3
fmul dword [ebx+wave]
fsin
fmulp st1, st0
fimul dword [edi]
fadd st0, st2
fabs
fist dword [ebx]
;posx += dist*dirx;
;posy += dist*diry;
;posz += dist*dirz;
fld st6
fmul st0, st1
faddp st4, st0
fld st5
fmul st0, st1
faddp st3, st0
fld st4
fmulp st1, st0
faddp st1, st0
;} while ((int)posz < 0x0200 && (int)dist>1);
cmp dword [ebx], 0x00000004
jbe colr
fist dword [ebx]
cmp dword [ebx], 0x00000800
jb cast
colr:
;int b = (int)fabs(posy*0x100/posz)<<2;
;int r = ((int)posx^(int)posz)&0x10;
;r = (int)(r*0x100/posz);
fild dword [ResX]
fdivrp st1, st0
fmulp st1, st0
fimul dword [edi]
fabs
fistp dword [edi]
mov eax, [edi]
stosb
stosb
stosb
scasb
jmp draw
db 0
16
General coding questions / Re: Line segment collision, rotational collision response?
« on: August 09, 2013 »
This thread might be of interest to you. ( Rigid Body Dynamics simulator )
http://www.dbfinteractive.com/forum/index.php?topic=1501.msg23060#msg23060
http://www.dbfinteractive.com/forum/index.php?topic=1501.msg23060#msg23060
18
ASM / Re: Wolfenstein 3D in 128 bytes
« on: March 09, 2013 »
very good, but you have a redraw problem and its very slow because you are setting the video mode with each new frame. If you set the video mode only once at the very start the redraw problem is not noticable and the speed is much better. But then you have no clear screen. Still a better option I think
19
Yabasic / Re: Question about a question
« on: December 21, 2012 »
When you say question do you mean using the input command or using if then else statements? Maybe this example will clear things up a little
Code: [Select]
rem this is a string input
print "Hello my name is yabasic"
input "What is your name?" Name$
print "Hello " + Name$ + " nice to meet you"
rem this is a numeric input
print "So " + Name$ + " can you answer this question for me"
print "I have 3 apples and I share 1 of my apples with you"
input "How many apples do I have left?" NumApples
if (NumApples = 2) then
print "Correct " + Name$ + " I have exactly 2 apples left."
elsif (NumApples < 2) then
print "No " + Name$ + " I have 2 apples left."
elsif (NumApples > 2) then
print "No " + Name$ + " I have 2 apples left."
else
print "No " + Name$ + " I have 2 apples left."
endif
20
General coding questions / Re: Improving the basic fire effect
« on: November 17, 2012 »
That is nice, You have more white in that pallet then the one I posted. The advantage of the one I posted is the size of the pallet generator. Two shifts (or adds) and two conditional moves. But of course such a simple generator is not going to output the best quality pallet.
The cool map is great for simulating convection. One thing that was mentioned by Hugo was that the cool map should be scrolled vertically at the same speed that the flames rise (one pixel per frame). I didn't implement this yet but he says that you can get nice tounges in the flames using this method.
Also his method for gathering heat is to take the pixels surrounding the current pixel and average
x-1, y
x+1, y
x, y-1
x, y+1
While in lodes version all of the heat is gathered from below the current pixel like this
x-1, y+1
x, y+1
x+1, y+1
x, y+2
With Hugos method heat will spread in any direction, while in Lodes method heat only rises.
The cool map is great for simulating convection. One thing that was mentioned by Hugo was that the cool map should be scrolled vertically at the same speed that the flames rise (one pixel per frame). I didn't implement this yet but he says that you can get nice tounges in the flames using this method.
Also his method for gathering heat is to take the pixels surrounding the current pixel and average
x-1, y
x+1, y
x, y-1
x, y+1
Code: [Select]
+---+
| |
+---+---+---+
| | X | |
+---+---+---+
| |
+---+
While in lodes version all of the heat is gathered from below the current pixel like this
x-1, y+1
x, y+1
x+1, y+1
x, y+2
Code: [Select]
+---+
| X |
+---+---+---+
| | | |
+---+---+---+
| |
+---+
With Hugos method heat will spread in any direction, while in Lodes method heat only rises.