As you probably know C4D is limited to 3 decimal places and thats frankly not enough in some situations.
So here’s some c++ code for the c4d plugin developer to get around that limitation. might be useful to some of you guys. maybe.

However its not possible to append unit strings (m, mm, °, etc.)

Looks like this:

The code after the break…

The code:

#include "c4d.h"

const LONG CINDIGO_REAL_CUSTOMGUI = 1000001; //TODO: get plugin ID

static LONG restypetable[] = { DA_REAL };

class CindigoRealDlg : public iCustomGui
     {
          INSTANCEOF(CindigoRealDlg, iCustomGui)
     private:
          BaseContainer m_settings;

          Real m_real;
          Bool m_tristate;

     public:
          CindigoRealDlg(const BaseContainer &settings, CUSTOMGUIPLUGIN *plugin)
          : iCustomGui(settings, plugin), m_real(), m_tristate(false), m_settings(settings)
          {

          }

          virtual void CustomGuiRedraw()
          {
          }

          virtual void DestroyWindow(void)
          {

          }

          virtual Bool CreateLayout (void)
          {
               AddEditNumberArrows(1000,0,80,0);

               return TRUE;
          }

          virtual Bool SupportLayoutSwitch()
          {
               return FALSE;
          }

          virtual Bool InitValues()
          {
               SetUnclampedReal(m_real);

               return TRUE;
          }

          void SetUnclampedReal(Real r)
          {
               SetReal(1000, r);
               String s = RealToString(r,-1,5);

               //if r == 0.0 set 0
               if (r == 0.0) {
                    s = "0";
               } else {
                    //cut of trailing zeros
                    LONG i = 0;
                    for(i = s.GetLength()-1; i > 0; i--)
                    {
                         if (s[i] != '0') break;
                    }
                    s = s.SubStr(0, i+1);
               }

               SetString(1000, s);
          }

          virtual LONG Message(const BaseContainer& msg, BaseContainer& result)
          {
               if ((msg.GetId() == BFM_ACTION) && msg.GetLong(BFM_ACTION_ID) == 1000)
               {
                    if (msg.GetLong(BFM_ACTION_VALCHG) || msg.GetReal(BFM_ACTION_VALUE,MAXREAL) != MAXREAL)
                    {
                         m_real = msg.GetReal(BFM_ACTION_VALUE);

                         SetUnclampedReal(m_real);

                         return TRUE; //message processed
                    }
               }

               return GeDialog::Message(msg,result);
          }

          virtual Bool Command(LONG id, const BaseContainer& msg)
          {
               switch (id)
               {
               case 1000:
                    {
                         BaseContainer m(msg);
                         m.SetLong(BFM_ACTION_ID, GetId());
                         m.RemoveData(BFM_ACTION_VALUE);
                         m.SetData(BFM_ACTION_VALUE, GetData().GetValue());
                         SendParentMessage(m);

                         break;
                    }
               }
               return TRUE;
          }

          virtual Bool SetData(const TriState &tristate)
          {
               m_real = tristate.GetValue().GetReal();
               m_tristate = tristate.GetTri();

               return TRUE;
          }

          virtual TriState GetData()
          {
               GetReal(1000, m_real);
               return GeData(m_real);
          }
     };

class CindigoRealGui : public CustomGuiData
     {
     public:
          virtual LONG GetId() { return CINDIGO_REAL_CUSTOMGUI; }

          virtual CDialog* Alloc(const BaseContainer &settings)
          {
               CindigoRealDlg* dlg = gNew CindigoRealDlg(settings, GetPlugin());
               if (!dlg) return NULL;

               CDialog *cdlg = dlg->Get();
               if (!cdlg) return NULL;

               return cdlg;
          }

          virtual void Free(CDialog *dlg, void *userdata)
          {
               if (!dlg || !userdata) return;
               CindigoRealDlg *sub = static_cast(userdata);
               gDelete(sub);
          }

#ifdef CINDIGO_C4D_VERSION_R115
          virtual const CHAR *GetResourceSym()
#else
          virtual CHAR *GetResourceSym()
#endif
          {
               return "CINDIGO_REAL_GUI";
          }

          virtual LONG GetResourceDataType(LONG *&table)
          {
               table = restypetable;
               return sizeof(restypetable)/sizeof(LONG);
          }
     };

Bool RegisterRealGUI()
{
     static BaseCustomGuiLib mylib;
     ClearMem(&mylib,sizeof(mylib));
     FillBaseCustomGui(mylib);

     return InstallLibrary(CINDIGO_REAL_CUSTOMGUI, &mylib, 1000, sizeof(mylib))

     &&

     RegisterCustomGuiPlugin("My String GUI", PLUGINFLAG_HIDE, gNew CindigoRealGui);
}

That’s what Twitter is for, right?

what a buggy application…

nonetheless nice and easy to use! awesome!

I just never noticed that. I might post here more often.

Probably just coding and Indigo stuff.

Heh, just bought me a color:

fused Crimson – #5c0004

2^24 colors, bet these guys will be rich real soon

Along with the Indigo Stable release there is a new Cindigo version, which features animation support and quite a few other improvements.

Get it here.

Cindigo 2.0 Stable
———————
* indigo instance will now be selected when created without a selected object
* deform mode for indigo instances fixed (does not render/export anymore when disabled)
* cindigo will always detect the scene scale, even if no indigo render settings present
* previews will always launch in the indigo GUI (temporary)
* re added animation export (static animations only)
* aperture diffraction default back to post process
* changed default sun direction
* changed indigo instance drawing mode default to “object”

Finally!

“Hi Everyone,
I’m pleased to announce the release of Indigo Renderer 2.0 stable.

The Indigo 2.0 series has been in Beta for the last 3 months, and has recently reached a point of sufficient stability to be released as a ’stable’ version.
Indigo 2.0 is the first commercial version of Indigo, and represents the latest results from over 5 years of development.

The Indigo graphical user interface (GUI) has been rewritten to improve power and ease of use.
Interactive tone mapping, layer blending etc.. is now possible with the GUI.
Major new Indigo features include motion blur, easy network rendering with a customised render node GUI, and full Unicode support.
Sub-surface scattering has been sped up, and aperture diffraction (glare) has been improved.

The Indigo exporter plug-ins have also been greatly improved, and now come with easy-to-use installers. Indigo exporter plug-ins can also now read and write Indigo material files, allowing artists to make use of the Indigo material database (http://www.indigorenderer.com/materials/), a free online repository of high-quality Indigo materials.

The Indigo 2.0 stable version sets a solid foundation for further improvements due in the 2.2 series, including large speed-ups and more realistic materials.

You can download it from:

http://www.indigorenderer.com/download

(Note: Indigo version 2.0.12 is considered 2.0 stable, so If you have already downloaded 2.0.12, don’t bother downloading it again.)”

No mac version yet, will follow soon…
Download it here

Changelog:

Cindigo 2.0.11
———————
* aperture diffraction now defaults to camera aperture diffraction (not post process)
* added functionality to the new export path settings
* enabled IES previews for mac version
* light layers are not chosen by number anymore but with a dropdown with names
* added layer names to render settings
* preview renderings start as working master now
* material halpers will be selected when created
* rgb gain is a percent slider now
* fixed bug with link materials and media
* removed export dialog

Cindigo 2.0.9.1
———————
* wrote a custom image header for all indigo tags/object/etc
* moved export settings from export dialog to render settings
* reorganized render settings
* small pigm import/linking fixes
* fixed crash when material link in texture tag was empty
* fixed bug in material assigning code when material link in mat helper was empty
* fixed R9 quickrender bug
* fixed quickrender fail when indigo path wasnt set before
* fixed quickrender path issue introduced in the mac version of Cindigo 2.0.9
* disabled all options in the export window that dont work
* layer fix for material helpers (R11)
* fixed render foregound alpha
* when creating a mat helper, a c4d material is automatically created and linked
* quickrender fix for mac version (which accidentally sent my whole desktop to nirvana…)

No documentation yet, but a new release adding functionality to the Indigo Instance object. The export routine was rewritten, to make instance export easier and faster. The Indigo Instance supports nesting now (instances of instances). Get it here.

Read the Changelog:

Cindigo 2.0.9
———————
* implemented alias_material for previewing linked materials
* gamma fix for imported materials with RGB
* implemented pigm import and linking
* exported materials will always be exported as pigms
* fixed emissive material icon for R11
* quickrender does not rely on the config file anymore
* Sun and sky will now be always drawn to a seperate layer than other lights
* fixed material inheriting and materials with selections
* added thread_priority command line switch
* added sun and sky layer
* fix for nested instance loops
* fix for transformaton issues with non-uniform scale
* nested indigo instances will now be drawn
* implemented instance export for the indigo instance object
* reworked the export routine ^again^ to make instance exporting easier
* small changes to motion blur

I’ll start working on some form of manual for Cindigo after the initial bugs of the recent version are fixed.

And as a complement i will release a package of testscenes along with the manual, about topics explained in it and some more advanced stuff.

Stay tuned