Welcome to Fractal Forums

> /usr/bin/hexdump obj.o | sed -ne '/^0000...\ /s/^0000...\ //g;p' | sed -ne '/\ /s/\ //g;p' 

414178452070203d0a31614773756973
6e6141413d20742075720a656523646e
727073657465000a

...make cmds...
cat obj.o | hexdump  | sed -ne '/^0000...\ /s/^0000...\ //g;p' | sed -ne '/\ /s/\ //g;p' > hexfile.txt  

[OPTIONS]
.Version = 2
.DEoption = -1
[constants and variables]
[SOURCE]
  cfg->x=fabs(cfg->x);
  cfg->y=fabs(cfg->y);
  cfg->z=fabs(cfg->z);
[END]

Description:

Test of compiling a formula with GCC.
It simply set (x,y,z)=abs(x,y,z)

objcopy -Obinary -j .text MB3D-formula-ex.o out.bin

bin2hex out.bin out.txt

#include <math.h>
__attribute__((packed)) struct TIteration3Dext {
double Cw,Rold,RStopD,x,y,z,w; // use with neg indizes before C1. w is also used for 3d ifs and abox analytic DE
double Px, Py, Pz;             //      actual position, never change these!  Can be used as input.
double Cx, Cy, Cz;             //+24   these are the constants for adding. Pxyz or the julia seed.  Cw is @-56 (begin of struct)
void*  PVar;                   //+48   the actual formulas adress of constants and vars, constants at offset 0 increasing, user vars below -8 
float  SmoothItD;              //+52
double Rout;                   //+56   the square of the vector length, can be used as input
int    ItResultI;              //+64
int    maxIt;                  //+68
float  RStop;                  //+72
int    nHybrid[6];             //+76   all formulas iteration counts or single weights in interpol-hybrid
void*  fHPVar[6];              //+100  all formulas pointer to constants+vars, PVars-8=0.5, use PVar for the actual formula
void*  fHybrid[6];             //+124  the formulas adresses
int    CalcSIT;                //+148
int    DoJulia;                //+152
float  LNRStop;                //+156
int    DEoption;               //+160
float  fHln[6];                //+164  for SmoothIts
int    iRepeatFrom;            //+188
double OTrap;                  //+192
double VaryScale;              //+200  to use in vary by its
int    bFirstIt;               //+208  used also as iteration count, is set to 0 on it-start
int    bTmp;                   //+212  tmpBuf, free of use.
double Dfree1;                 //+216
double Dfree2;                 //+224
double Deriv1;                 //+232  for 4D first deriv or as full derivs
double Deriv2;                 //+240
double Deriv3;                 //+248
float  SMatrix4[4][4];         //+256  for 4d rotation, used like most other values only by the programs iteration loop procedure
};

// fastcall is not quite delphi fastcall.
// first two args are ok, third is in ecx in delphi, on stack here.
void __attribute__((fastcall)) formula(
             double* x,      // [eax]
             double* y,      // [edx]
             double* arg,    // [ebp+8], points to TIteration3Dext.C1
             void* dummy     // so we end w/ ret 8 as delphi expects
             ) {
  // Compute ptr to proper start of TIteration3Dext struct.
  struct TIteration3Dext* cfg = (struct TIteration3Dext*)(arg-7);

  // Read / write some fields as demonstration.. not a real formula ;-)
  double tmp=cfg->x;
  cfg->x=cos(sin(cfg->y));
  cfg->y=tmp;
}

gcc -c -m32 -O3 -mfpmath=387 -ffast-math sineswap.c

objdump -D sineswap.o

sineswap.o:     file format pe-i386


Disassembly of section .text:

00000000 <@formula@16>:
   0:   55                      push   %ebp
   1:   89 e5                   mov    %esp,%ebp
   3:   8b 45 08                mov    0x8(%ebp),%eax
   6:   83 e8 38                sub    $0x38,%eax
   9:   8b 50 18                mov    0x18(%eax),%edx
   c:   8b 48 1c                mov    0x1c(%eax),%ecx
   f:   dd 40 20                fldl   0x20(%eax)
  12:   d9 fe                   fsin
  14:   d9 ff                   fcos
  16:   dd 58 18                fstpl  0x18(%eax)
  19:   89 50 20                mov    %edx,0x20(%eax)
  1c:   89 48 24                mov    %ecx,0x24(%eax)
  1f:   c9                      leave
  20:   c2 08 00                ret    $0x8
  23:   90                      nop

objcopy -Obinary -j .text sineswap.o sineswap.bin

bin2hex sineswap.bin sineswap.txt

[OPTIONS]
.Version = 2
.DEoption = -1
[CODE]
5589E58B450883E8388B50188B481CDD4020D9FED9FFDD5818895020894824C9C2080090
[END]

Description:

Test of compiling a formula with GCC.

Mandelbulb3Dv18{
b.....Y/...g2...w....26...U2xSE.FEG1.TLyGzcFHn2Ezkskg1RPYyvTB4OmJcqszipiyP.9Q4zj
................................3CcamACAtz1.......EO./..................y.2...wD
...Uz.....UR..../wU0/......q/...W/....E3.....2LNaiUt1joD/w.........m/dkpXm1.....
z.UaNadD12..0..........wz..................................u1....y1...sD...../..
.z1...kDmxchI3E6bxnNtGvRevNwy6EccKb8ZDlDyOAa4uMzGwvZyxtOCCPKzUDDlGyIvAqD7f84AINX
xvfDDzwW9qnMz8kgNCnrmapD......Ia2...g7........sD.6....sD..E.....................
.............oAnAt1...sD....z.Lv15.2iDQ.kuyk/.pv15.wjDQ.E0zk/.Hw15......Q....k1.
..................kz.wzzz1EM.c6.P....61...EK....Q/...c3...UD....5/...I1.....SF52
...U.ydelyjeYFnzTeOgzf8No.6.2c..zzzz............4............0........k.8.kXWF1.
.sM93P58iz9.MmnWK2zwz0........../EU0.wzzz1...........s/...................E.2c..
zzzz.............0...................2./8.kzzzD............8....................
/EU0.wzzz1....................................uBZ.U7EgU7tj/eVv1.oQm2oElCnueM.YXB
bYX7Ot6Ul/.8Gsm0Drb3jC4.a.l0aUWTUSH7.M029MmWy/uBZ.U7EgU7hv5crI0.a.l0aIoTUSH7.M02
9Mmfz/uBZ.U7EgU7...crIGJzzFoTuIdyzngi8qdxzZX.4rU................................
E....6....E.....I.........kQdtKNnRLMk/..........................................
...................6./..........................................................
................................................................................
.....................2..........0....YYPoJqNZ756ExqRZ75.........................
8............................./E........kz9.....................................
................................................................................
................................}

struct constants{
    double const1;
    double const2;
    ...etc.
};
struct variables{
   ...etc. //they should be inserted in reverse order?
   float var4;//[edi-20h]
   longint var3;//[edi-1ch]
   double var2;//[edi-18h]
   double var1;//[edi-10h]
   double dummy; //corrsponding to [edi-08h] because the "1st" accessible variable is at -0x10 
}
...
//In formula
   struct constants *pconst=(struct constants *) cfg->pVar;
   struct variables *pvar=(struct variables *)(((char *)pconst)-sizeof(struct variables));//not sure about the syntax or even if this is correct.
...

/*
Mandelbulb 3d Formula example. 
Original code by marius and jesse.
Modified by knighty. Apr 2015.
Work in progress.
No warranty.
Compilation using mingw and msys:
-Compile with (replace "theFormulaFilename" by actual c file name): 
	gcc -c -m32 -O3 -mfpmath=387 -ffast-math -march=pentium4 theFormulaFilename.c
  For now sse is not used because Gcc is too 
 good at optimizing :)) for example abs() translates to an sse and operation against 0x7fff... 
 but unfortunately that constant is put in .rdata section. 
 Trying to emulate it in c gives ugly code with a lot of registers/memory moves. 
 Maybe using intrinsics? Any idea? 
-Verify asm code: 
	objdumb -D theFormulaFilename.o
  This is necessary to check that there are no library functions call and that there is 
 only .text "segment" no .rdata or something like that or a call to external function.
-Extract machine code:
	objcopy -Obinary -j .text theFormulaFilename.o theFormulaFilename.bin
-Convert machine code from binary to hexadecimal:
	bin2hex theFormulaFilename.bin theFormulaFilename.m3f
(bin2hex is not part of msys or mingw. any other binary file editor would do the job)
-edit theFormulaFilename.m3f in a text editor to add MB3D stuff.
*/
/*Includes*************************************************/
#include <math.h>
/*MB3D structures definitions*************************************************/
//This structure is specific to dIFS. The use of most of it is unknown and should not be modified.  
__attribute__((packed)) struct TIteration3Dext {
double something; // -0x88 ; used in sphereheightmap.m3f
double dum0; // -0x80 ; unknown
double x; // -0x78
double y; // -0x70
double z; // -0x68
double dum1[8]; //unknown
double DE2T; // -0x20 ; Output: distance estimate to current object
double dum2[17]; //unknown
double accumulatedScale; // +0x70
double dum3; // +0x78; unknown
double OTforCol; // +0x80
double dum4[16]; //unknown
//void * sphericalMap; // +0x108; pointer to function
};
__attribute__((packed)) struct Sconsts{
	double Pie;//just to use a constant
	long long int abscst;
};
__attribute__((packed)) struct Svars{//in the reverse order wrt m3f file
	double Zadd;
	double Yadd;
	double Xadd;
	double Scale;
	double Bevel;
	double HalfLengthZ;
	double HalfLengthY;
	double HalfLengthX;
	double Dummy;//not used. What is it good for?
};
/*Macros**************************************************/
#define MAX(x,y) ((x)>(y) ? (x) : (y))
/*Local functions declaration*************************************************/
//Routines must be declared here and implemented after formula().
//This is in order to set the beginning of the machine code at the beginning of formula.
//Notice that if optimizations are disabled, the compiler may output routines code before formula's code.
inline void TheFormula(char* siarg, char* diarg);
/*Formula implementation*************************************************/
// Not a standard calling convention. this seems to be called from an asm code in MB3D.
// So we need to save almost all registers. the compiler generates the code to save/restore ebp
// esi and edi are not modified (or restored?)!???
//
// the arguments of this function are in edi and esi registers.
// esi points to the context structure
// edi points to constants (negative displacements for variables)
// 

void formula(void) {//Big overhead. The only solution I could find. Any Idea?
	asm("push %eax\n\tpush %ebx\n\tpush %ecx\n\tpush %edx\n\t");//save registers :/
	asm("push %edi\n\tpush %esi\n\t");//arguments to TheFormula
	asm("call _TheFormula");
	asm("pop %edx\n\tpop %edx\n\t");//clean stack because the call convention is C's. It coud be: addl $0x08,esp instead.
	asm("pop %edx\n\tpop %ecx\n\tpop %ebx\n\tpop %eax\n\t");//restore registers :/
}

/*Local functions implementation*************************************************/
inline void TheFormula(char* siarg, char* diarg) {
//DO NOT MODIFY BEGIN
	// Compute ptr to proper start of TIteration3Dext struct.
  struct TIteration3Dext* pctx = (struct TIteration3Dext*)(siarg-0x88);
  // get pointer to constants.
  struct Sconsts* pconst=(struct Sconsts*) (diarg);
  // get pointer to variables.
  struct Svars*   pvar=(struct Svars*) (((char*)pconst)-sizeof(struct Svars));
//DO NOT MODIFY END
  // Draw a box
  double x=pctx->x, y=pctx->y, z=pctx->z;
  x=fabs(x) - (pvar->HalfLengthX - pvar->Bevel);
  y=fabs(y) - (pvar->HalfLengthY - pvar->Bevel);
  z=fabs(z) - (pvar->HalfLengthZ - pvar->Bevel);
  double DE = MAX(x,MAX(y,z));
  if (DE>0.){
	x = MAX(0.,x);
	y = MAX(0.,y);
	z = MAX(0.,z);
	DE = MAX(DE, sqrt(x*x+y*y+z*z));
  }
  pctx->DE2T = DE - pvar->Bevel;
  // Now do translation and scaling
  pctx->x = pctx->x * pvar->Scale + pvar->Xadd;
  pctx->y = pctx->y * pvar->Scale + pvar->Yadd;
  pctx->z = pctx->z * pvar->Scale + pvar->Zadd;
  pctx->accumulatedScale = pctx->accumulatedScale * pvar->Scale;
}

[OPTIONS]
.Version = 6
.DEoption = 20
.Double X halfwidth = 1
.Double Y halfwidth = 1
.Double Z halfwidth = 1
.Double Fillet = 0
.Double Scale = 1
.Double X add = 0
.Double Y add = 0
.Double Z add = 0
[CONSTANTS]
Double = 0 
INT64 = $7FFFFFFFFFFFFFFF
[CODE]
5589E5505351525756E8080000005A5A5A595B585DC35589E583EC088B4D0C8B45082D880000
008D51B8DD4010DD4018DD4020DD55F8DD4220D9C3D9E1DC6238D8C1D9C3D9E1DC6230D8C2D9
CBD9E1DC6228D8C2D9CBDBF1D9C1DBC1DBF4DAC4D9EED9C9DBF1762ED9CBDBF1DAC1D8C8D9CA
DBF1DAC1D8C8D9CDDBF1DAC1DDD9D8C8D9CCDEC1DEC3D9CAD9FAD9CADBF2DAC2DDDAEB08DDDD
DDD8DDD8DDD8DEE9DD5868DD4218DCCAD9CADC4210DD5810D8C9DC4208DD5818DD45F8D8C9DC
41B8DD5820DC88F8000000DD98F8000000C9C3909090
[END]

Box shape dIFS with rounded edge. no OTrap coloring for now.

/*
Mandelbulb 3d Formula example. 
Original code by marius and jesse.
Modified by knighty. Apr 2015.
Work in progress.
No warranty. This is made by a noob ;)
Compilation using mingw and msys (stricly speaking msys is not required... in principle):
-Compile with (replace "theFormulaFilename" by actual c file name): 
	gcc -c -m32 -O3 -mfpmath=387 -ffast-math -march=pentium4 theFormulaFilename.c
  SSE2 can be used by setting: -mfpmath=both and adding the switch: -msse2 
  If you want to use sse2, better use assembler. c's sse generated code is just annoying! and not necessarily faster. :(
  Anyway, it is still possible to edit the assembler code generated by the compiler...
  If you use sse2, use the macros defined below. Otherwise the compiler will use variables stored in .rdata whith will make the formula unusable.
-Verify asm code: 
	objdump -D theFormulaFilename.o
  This is necessary to check that there are no library functions call and that there is 
 only .text "segment" no .rdata or something like that or a call to external function.
-Extract machine code:
	objcopy -Obinary -j .text theFormulaFilename.o theFormulaFilename.bin
-Convert machine code from binary to hexadecimal:
	bin2hex theFormulaFilename.bin theFormulaFilename.m3f
(bin2hex is not part of msys or mingw. any other binary file editor would do the job)
-edit theFormulaFilename.m3f in a text editor to add MB3D stuff.
*/
/*Defines**************************************************/
#define USE_SSE2
/*Includes*************************************************/
#include <emmintrin.h>
#include <math.h>
/*MB3D structures definitions*************************************************/
//This structure is specific to dIFS. The use of most of it is unknown and should not be modified.
//Edit: it seems that it is almost the same as for non dIFS.  
__attribute__((packed)) struct TIteration3Dext {
double something; // -0x88 ; used in sphereheightmap.m3f
double dum0; // -0x80 ; unknown
double x; // -0x78
double y; // -0x70
double z; // -0x68
double dum1[8]; //unknown
double DE2T; // -0x20 ; Output: distance estimate to current object
double dum2[17]; //unknown
double accumulatedScale; // +0x70
double dum3; // +0x78; unknown
double OTforCol; // +0x80
double dum4[16]; //unknown
//void * sphericalMap; // +0x108; pointer to function
};
__attribute__((packed)) struct Sconsts{//in the same order as m3f file's [constant] section
	double Pie;//just to use a constant
	long long int abscst;//for ABS()
	long long int negcst;//for NEG()
};
__attribute__((packed)) struct Svars{//in the reverse order wrt m3f file
	double Zadd;
	double Yadd;
	double Xadd;
	double Scale;
	double Bevel;
	double HalfLengthZ;
	double HalfLengthY;
	double HalfLengthX;
	double Dummy;//not used. What is it good for?
};
/*Macros**************************************************/
//this macro changes the type of a variable without conversion.
#define REINTERPRET(x,type) (*((type *) &(x)))
//
#define MAX(x,y) ((x)>(y) ? (x) : (y))
#define MIN(x,y) ((x)<(y) ? (x) : (y))
//with sse2, fabs() and negating generates a logical instruction with a constant stored in .rdata 
//use these instead of writing: fabs(bar); or foo=-bar; when using sse2.
#ifdef USE_SSE2
	#undef fabs
	#define ABS(x) (Abs(x, pconst))
	#define NEG(x) (Neg(x, pconst))
#else
	#define ABS(x) (fabs((x)))
	#define NEG(x) (-(x))
#endif
/*Local functions declaration and/or implementation*************************************************/
//if the function is declared static it will not be exported and it won't be in the obj file if inlined
inline void __attribute__((fastcall)) TheFormula(char* siarg, char* diarg);//implemented after formula because formula code must be placed before this function's code.
#ifdef USE_SSE2
static inline double Abs(double x, struct Sconsts* pconst){
	__m128d v=_mm_set1_pd (x);//not perfect
	__m128d w=_mm_set1_pd (REINTERPRET(pconst->abscst,double));//not perfect either
	__m128d r=_mm_and_pd (v,w);
	return _mm_cvtsd_f64 (r);
}
static inline double Neg(double x, struct Sconsts* pconst){
	__m128d v=_mm_set1_pd (x);
	__m128d w=_mm_set1_pd (REINTERPRET(pconst->negcst,double));
	__m128d r=_mm_xor_pd (v,w);
	return _mm_cvtsd_f64 (r);
}
#endif
/*Formula implementation*************************************************/
// Not a standard calling convention. this is called from an asm code in MB3D which assumes that %ecx is not modified.
// We need to save %ecx register.
// esi and edi (and ebx?) are not modified (or restored?)!??? 
//
// the arguments of this function are in edi and esi registers.
// esi points to the context structure
// edi points to constants (negative displacements for variables)
void formula(void) {//Big overhead. The only solution I could find. Any Idea?
	asm("push %ecx\n\t");//save ecx
	asm("mov %esi,%ecx\n\t");
	asm("mov %edi,%edx\n\t");//arguments to TheFormula
	asm("call @TheFormula@8\n\t");//this is the compiler generated name for TheFormula. If cdecl the generated name is "_TheFormula"
	//is it possible to get TheFormula inlined? The following doesn't work.
	//void (*foo)() = (void (*)())&TheFormula;
	//foo();
	asm("pop %ecx");//restore ecx
}

/*The actual formula*************************************************/
inline void __attribute__((fastcall)) TheFormula(char* siarg /*ecx*/, char* diarg/*edx*/) {
//DO NOT MODIFY BEGIN
	// Compute ptr to proper start of TIteration3Dext struct.
  struct TIteration3Dext* pctx = (struct TIteration3Dext*)(siarg-0x88);
  // get pointer to constants.
  struct Sconsts* pconst=(struct Sconsts*) (diarg);
  // get pointer to variables.
  struct Svars*   pvar=(struct Svars*) (((char*)pconst)-sizeof(struct Svars));
//DO NOT MODIFY END
  // Draw a box
  double x=pctx->x, y=pctx->y, z=pctx->z;
  x=ABS(x) - (pvar->HalfLengthX - pvar->Bevel);
  y=ABS(y) - (pvar->HalfLengthY - pvar->Bevel);
  z=ABS(z) - (pvar->HalfLengthZ - pvar->Bevel);
  double DE = MAX(x,MAX(y,z));
  if (DE>0.){
	x = MAX(0.,x);
	y = MAX(0.,y);
	z = MAX(0.,z);
	DE = MAX(DE, sqrt(x*x+y*y+z*z));
  }
  pctx->DE2T = DE - pvar->Bevel;
  // Now do translation and scaling
  pctx->x = pctx->x * pvar->Scale + pvar->Xadd;
  pctx->y = pctx->y * pvar->Scale + pvar->Yadd;
  pctx->z = pctx->z * pvar->Scale + pvar->Zadd;
  pctx->accumulatedScale = pctx->accumulatedScale * pvar->Scale;
}

[OPTIONS]
.Version = 6
.DEoption = 20
.SSE2
.Double X halfwidth = 1
.Double Y halfwidth = 1
.Double Z halfwidth = 1
.Double Fillet = 0
.Double Scale = 1
.Double X add = 0
.Double Y add = 0
.Double Z add = 0
[CONSTANTS]
Double = 0 
INT64 = $7FFFFFFFFFFFFFFF
INT64 = $8000000000000000
[CODE]
5589E5505351525756E8080000005A5A5A595B585DC35589E583EC088B4D0C8B45082D880000
008D51B8DD4010DD4018DD4020DD55F8DD4220D9C3D9E1DC6238D8C1D9C3D9E1DC6230D8C2D9
CBD9E1DC6228D8C2D9CBDBF1D9C1DBC1DBF4DAC4D9EED9C9DBF1762ED9CBDBF1DAC1D8C8D9CA
DBF1DAC1D8C8D9CDDBF1DAC1DDD9D8C8D9CCDEC1DEC3D9CAD9FAD9CADBF2DAC2DDDAEB08DDDD
DDD8DDD8DDD8DEE9DD5868DD4218DCCAD9CADC4210DD5810D8C9DC4208DD5818DD45F8D8C9DC
41B8DD5820DC88F8000000DD98F8000000C9C3909090
[END]

Box shape dIFS with rounded edge. no OTrap coloring for now.