/*==========================================================================
 *                                                                         *
 *  Copyright (C) 2002 Lev Dymchenko                                       *
 *                                                                         *
 *  VirtualRay Engine (Spherical Engine) Header file                       *
 *                                                                         *
 ***************************************************************************/

                                                 
#ifndef Spherical_Engine_Interface
#define Spherical_Engine_Interface

//#define import_specificator extern "C" __stdcall
#define import_specificator 
#define callconv_specificator __stdcall


//#pragma pack(push,4)


#ifndef spherical_engine_dll	

#include <string> 
using namespace	std;

#include "Types@.h"
#include "LinAlg@.h"

typedef rvectort rvector3t;
typedef basisobj basis9obj;

#define se_api	import_specificator
#define callconv callconv_specificator

#else

#ifndef Typesh
#include "Geometry_.h"
#else
typedef rvectort rvector3t;
typedef basisobj basis9obj;
#endif

#define	se_api __declspec(dllexport) 
#define callconv callconv_specificator

#endif

//=====================================================================
//=====================================================================

class SphereObj;
typedef SphereObj* SphereObjpt;

class LightObj;
typedef LightObj* LightObjpt;

class EntityObj;
typedef EntityObj* EntityObjpt;

class SceneObj;
typedef SceneObj* SceneObjpt;

class TexturerObj;
typedef TexturerObj* TexturerObjpt;

class RenderObj;
typedef RenderObj* RenderObjpt;


class SEObj
{
  public:

  virtual void callconv unallocate()=0;
};


#pragma pack(push,4)
struct sphereinfot
{
  bool flvisible;
  float radius;
  rvector3t centerp;
  basis9obj basis;
  basis9obj* basispointer;
  bool fltexture;
  bytecolor3t color;
  i32 lotxtype,hitxtype;
  bool fltransparent;
  bytecolor3t alfa;
  bool fllighting;
  bool flownbgillum;
  bytecolor3t bgillum;
  bool flshadowcasting;
  bool flshading;
  bool fllocalshadowing;                 
};
typedef sphereinfot* sphereinfopt;
#pragma pack(pop)

class SphereObj:public SEObj
{
  public:

  virtual void callconv setvisible(bool flvisible)=0;	

  virtual void callconv setposvf(const rvector3t& centerp, float radius)=0;
  virtual void callconv setpos4f(float x, float y, float z, float radius)=0;
  virtual void callconv setposv(const rvector3t& centerp)=0;
  virtual void callconv setpos3f(float x, float y, float z)=0;
  virtual void callconv setposfp(const float* centerpp)=0;
  virtual void callconv getposfp(float* centerpp)=0;
  virtual void callconv setradius(float sphereradius)=0;	
  virtual float callconv getradius()=0;
  virtual void callconv setposgs(const gspheret& gsphere)=0;
  virtual gspheret callconv getposgs()=0;

  virtual void callconv setinvisibility(bool flinvisibility)=0;

  virtual void callconv settransforming(bool fltransforming)=0; 

  //virtual void callconv setclipsphere(float* clipspherecenterpp, float clipsphereradius)=0;  
  //virtual void callconv setclipsphere(float x, float y, float z, float clipsphereradius)=0;  
  //virtual void callconv setclipsphere(const rvector3t& clipspherecenterp, float clipsphereradius)=0;  
		
  virtual void callconv setbasisbp(const float*	basisp)=0;	
  virtual float* callconv getbasisp()=0;
  virtual void callconv setbasisb(const basis9obj& basis)=0;
  virtual basis9obj callconv getbasis()=0;
  virtual void callconv setbasispointer(basis9obj* basisp)=0;
  virtual void callconv mulbasisright(float* rightmatrixp)=0;
  virtual void callconv mulbasisleft(float* leftmatrixp)=0;
  virtual void callconv onbasischange()=0;

  virtual void callconv enabletexture(bool fltexture)=0;	
  virtual void callconv setcolorfp(const float* col)=0;	
  virtual void callconv setcolor3f(float r, float g, float b)=0;	
  virtual void callconv setcolor3b(byte r, byte g, byte b)=0;	
  virtual void callconv setcolorb(bytecolor3t col)=0;
  virtual void callconv setlotexture(i16 lotxtype)=0;	
  virtual void callconv sethitexture(i16 hitxtype)=0;	
  virtual void callconv settexture(i16 lotxtype, i16 hitxtype)=0;	

  virtual void callconv enablelighting(bool flspherelighting)=0;	
  virtual void callconv enableownbgillum(bool flownbgillum)=0;
  virtual void callconv setbgillumfp(const float* backgroundillump)=0;	
  virtual void callconv setbgillum3f(float r, float g, float b)=0;
  virtual void callconv setbgillumbp(const byte* backgroundillump)=0;
  virtual void callconv setbgillum3b(byte r, byte g, byte b)=0;
  virtual void callconv setbgillumb(bytecolor3t backgroundillum)=0;
		
  virtual void callconv enabletransparency(bool fltransparency)=0;	
  virtual void callconv settransparencyfp(const float* coefp)=0;	
  virtual void callconv settransparency3f(float r, float g, float b)=0;
  virtual void callconv settransparencybp(const byte* coefp)=0;	
  virtual void callconv settransparency3b(byte r, byte g, byte b)=0;	
  virtual void callconv settransparencyb(bytecolor3t coef)=0;	
  virtual void callconv enablevoltransparency(bool flvoltransparency)=0;
  virtual void callconv setvoltransptable(void* voltablep)=0;

  virtual void callconv enableshadowcasting(bool flcastingshadow)=0;	
  virtual void callconv enableshading(bool flshading)=0;
  virtual void callconv setlocalshadowing(bool fllocalshadowcasting)=0;
  virtual void callconv setshadowtype(bool flcastingshadow, bool flshading, bool fllocalshadowcasting)=0;
  virtual void callconv setshadowid(i32 shadowidentifier)=0;	
  virtual void callconv setshadowedinterval(i32 lobound, i32 hibound)=0;
  virtual void callconv setlightid(i32 lightid)=0;	

  virtual void callconv set(const sphereinfot* sphereinfop)=0;

  //virtual void callconv addsecantsphere(sphguidt secantsphereguid)=0; 
  //virtual bool callconv removesecantsphere(sphguidt secantsphereguid)=0;
  //virtual void callconv removeallsecantspheres()=0;
  //virtual void callconv updatesecantsphereinfo(sphguidt secantsphereguid)=0;
  //virtual void callconv updateallsecantsphereinfo()=0;

  //virtual secantguidt callconv insertsecantsphere(float*	secantcenterpp, float secantradius)=0;
  //virtual secantguidt callconv insertsecantsphere(float x, float y, float z, float secantradius)=0;
  //virtual secantguidt callconv insertsecantsphere(const rvector3t&	secantcenterp, float secantradius)=0;

  //virtual secantguidt callconv insertrelativesecantsphere(float*	secantcenterpp, float secantradius)=0;
  //virtual secantguidt callconv insertrelativesecantsphere(float	x, float y, float z, float secantradius)=0;
  //virtual secantguidt callconv insertrelativesecantsphere(const rvector3t&	secantcenterp, float secantradius)=0;

  //virtual secantguidt callconv insertrelativesecantplane(float* planenormalp, float d)=0;
  //virtual secantguidt callconv insertrelativesecantplane(float x, float y, float z, float d)=0;
  //virtual secantguidt callconv insertrelativesecantplanev(const rvector3t& planenormal, float d)=0;

  //virtual bool callconv deletesecantentity(secantguidt	secantentityguid)=0;	
  //virtual void callconv deleteallsecantentities()=0;  

  //virtual void callconv clearsecantinfo()=0;
		
  //virtual void callconv activateintersection()=0;
  //virtual void callconv enableintersection(bool flenable)=0;
  //virtual void callconv deactivateintersection()=0;

  //virtual void callconv excludefromintersect()=0; 
  //virtual void callconv updatedependentsecantinfo()=0;

  //virtual void callconv setsecantinfocelladdend(byte addend)=0;
  //virtual void callconv enlargesecantinfo(byte addend)=0;
  //virtual void	callconv createsecantinfo(byte apprsecantspherequ, byte addendqu)=0;
  //virtual void callconv destroysecantinfo()=0;

  virtual void callconv setentity(const EntityObj* newentityp)=0;  // Include sphere into specified entity. Null value excludes sphere from entity if it exists.

  virtual void callconv copy(const SphereObj* soursep)=0;
  virtual void callconv setdefault()=0;
};

//=====================================================================

#define LightType_Global 0
#define LightType_Local  1

#pragma pack(push,4)
struct lightinfot
{
  i32 flenable;
  rvector3t centerp;
  float distance;
  i32 flautodistance;
  float minintense;
  i32 lightid;
  i32 lighttype;
  i32 fllocallight;
  float intense;
  float a0,a1,a2;
  float r,g,b;
};
typedef lightinfot* lightinfopt;
#pragma pack(pop)

class LightObj:public SEObj
{
  public:

  virtual void callconv set(const lightinfot* lightinfop)=0;
  virtual void callconv enable(bool flenable)=0;
  virtual void callconv settype(i32 lighttype)=0;
  virtual void callconv setid(i32 lightid)=0;
  virtual void callconv setcenterv(const rvector3t& centerp)=0;
  virtual void callconv setcenter3f(float x, float y, float z)=0;
  virtual void callconv setcenterfp(const float* centerpp)=0;
  virtual void callconv settransforming(bool fltransforming)=0;
  virtual void callconv setdistance(float distance)=0;
  virtual void callconv enableautodistance(bool flautodistance)=0;
  virtual void callconv setminintense(float minintense)=0;
  virtual void callconv setintense(float intense)=0;
  virtual void callconv setcoef(float a0, float a1, float a2)=0;
  virtual void callconv setcolorfp(const float* colorp)=0;
  virtual void callconv setcolor3f(float r, float g, float b)=0; 
  virtual void callconv setcolorbp(const byte* colorp)=0;
  virtual void callconv setcolor3b(byte r, byte g, byte b)=0;
  virtual void callconv setcolorb(bytecolor3t color)=0;
};

//=====================================================================

class SphereHolderObj:public SEObj
{
  public:

  virtual SphereObj* callconv allocatesphere()=0;
};
typedef SphereHolderObj* SphereHolderObjpt;


class EntityObj:public SphereHolderObj
{
  public:

  virtual void callconv setvisible(bool flentityvisible)=0;

  virtual void callconv setspherevf(const rvector3t& centerp, float radius)=0;
  virtual void callconv setsphere4f(float x, float y, float z, float radius)=0;
  virtual void callconv setspherev(const rvector3t& centerp)=0;
  virtual void callconv setsphere3f(float x, float y, float z)=0;
  virtual void callconv setsphereradius(float radius)=0;
  virtual float callconv getsphereradius()=0;
  virtual void callconv setspheregs(const gspheret& gsphere)=0;
  virtual const gspheret& callconv getsphere()=0;
  virtual const rvector3t& callconv calculatespherecenter()=0;
  virtual float callconv calculatesphereradius()=0;
  virtual const gspheret& callconv calculatesphere()=0;
  virtual void callconv enablesphereautocalculation(bool flenable)=0;

  virtual void callconv settransforming(bool fltransforming)=0;

  virtual i32 callconv getentityshadowid()=0;
  virtual void callconv setlightid(i32 lightid)=0;

  virtual void callconv clear()=0;
};

//=====================================================================

class SceneObj:public SphereHolderObj
{
  public:

  virtual void callconv setbgillumfp(const float* backgroundillump)=0;	
  virtual void callconv setbgillum3f(float r, float g, float b)=0;
  virtual void callconv setbgillumbp(const byte* backgroundillump)=0;
  virtual void callconv setbgillum3b(byte r, byte g, byte b)=0;
  virtual void callconv setbgillumb(bytecolor3t backgroundillum)=0;

  virtual SphereObj* callconv getskysphere()=0;
  virtual SphereObj* callconv getsurfacesphere()=0;

  virtual SphereObj* callconv getdefaultsphere()=0;

  virtual LightObj* callconv allocatelight()=0;
  virtual EntityObj* callconv allocateentity(i32 maxspherequ=32)=0;

  virtual void callconv attachtexturer(TexturerObj* texturerp)=0;

  virtual void callconv setsurface(bool flsurface)=0;

  virtual void callconv clear()=0;
};

//=====================================================================

class TexturerObj:public SEObj
{
  public:

  virtual bool callconv inserttexture(i16	texturetype, const char* filename)=0;
  virtual void callconv deletetexture(i16 texturetype)=0;

  virtual void callconv setcashdir(const char* cashdirectory)=0;
  virtual void callconv enablecash(bool flenable)=0;

  virtual void callconv setnewpixelformat(pixelformatt newpixelformat)=0;
};

//=====================================================================

#define RenderISet_SSEEMMX 3
#define RenderISet_FPUEMMX 2
#define RenderISet_FPUMMX  1

#pragma pack(push,4)
struct renderinfot
{
		basis9obj viewbasis;	 // Camera basis. Axis z look forward.
		rvector3t viewpoint;  // Camera position
  i32 instructionset;  // Processor instruction set used by render
  i32 flsseapproximation;  // Use approximation in functions like sqrt 
  i32 x0,y0;  // Upper left corner of rendered screen in surface
		i32 flshadows;  // Enable shadows
  i32 flqualityshadows;  // Enable quality per pixel shadows (only for SSE)
  float shadowsoftness;  // Coefficient of shadow's softness (only for SSE)
  i32 fltextures;  // Enable textures
  i32 flqualitytextures;  // Enable quality textures
  i32 flinternalddraw;  // Use internal engine's DDraw manager
		i32 flexternalddrawsurface;  // Rendered to external DDraw surface 
		w32 ddrawsurface;  // External DDraw surface
		w32 screensurfacep;  // Pointer to pixel array
		i32 wpitch;  // Pitch size used with screensurfacep
};
typedef renderinfot* renderinfopt;
#pragma pack(pop)

#pragma pack(push,4)
struct renderstatinfot
{
  i32 overallsec1000;
  i32 prerenderingsec1000;
  i32 raytracingsec1000;
  i32 preanalysissec1000;
  i32 lightingsec1000;
  i32 intersectingsec1000; 
  i32 intersectionqu;
  i64 overalltick;
  i64 prerenderingtick;
  i64 raytracingtick;
  i64 preanalysistick;
  i64 lightingtick;
  i64 intersectingtick; 
}; 
typedef renderstatinfot* renderstatinfopt;
#pragma pack(pop)

#pragma pack(push,4)
struct	initrenderinfot
{
		float viewsizex,viewsizey;  // View width and heigth. Width=2*tan(horizontalviewangle/2)    
		i32 screensizex,screensizey;  // Rendered screen resolution
  i32 tilequ;  // Quantity of screen tiles accros. From 16 to 64.
  i32 threadqu;  // Quantity of threads used by render
};
typedef initrenderinfot* initrenderinfopt;
#pragma pack(pop)

class RenderObj:public SEObj
{
  public:

  virtual bool callconv transformspherev(const rvector3t& centerp, rvector3t& newcenterp)=0;
  virtual bool callconv transformsphere3f(float x, float y, float z, float& newx, float& newy, float& newz)=0;
  virtual bool callconv transformspherefp(const float* centerpp, float* newcenterpp)=0;
 
  virtual bool callconv issphereoverhorizonvf(const rvector3t& centerp, float radius)=0;
  virtual bool callconv issphereoverhorizon4f(float x, float y, float z, float radius)=0;
  virtual bool callconv issphereoverhorizonfp(const float* centerpp, float radius)=0;
  virtual bool callconv issphereoverhorizongs(const gspheret& gsphere)=0;

  virtual bool callconv isspherevisiblevf(const rvector3t& centerp, float radius, bool fltransforming=true)=0;
  virtual bool callconv isspherevisible4f(float x, float y, float z, float radius, bool fltransforming=true)=0;
  virtual bool callconv isspherevisiblefp(const float* centerpp, float radius, bool fltransforming=true)=0;
  virtual bool callconv isspherevisiblegs(const gspheret& gsphere, bool fltransforming=true)=0;

  virtual void callconv setrenderinfo(const SceneObj* scenep, const renderinfot& renderinfo)=0;
  virtual bool callconv renderscene()=0;

  virtual void callconv setopt(i32 param1, i32 param2)=0;
  virtual void callconv setdefaultopt()=0;

  virtual void callconv clearstat()=0;
  virtual void callconv getstat(renderstatinfot* renderstatinfop)=0;

  virtual void callconv cleardevstat()=0;
  virtual void callconv getdevstat(void* devrenderstatinfop)=0;

  virtual void callconv init(const initrenderinfot& initrenderinfo)=0;  // initialize object
};

//=====================================================================

#pragma pack(push,4)
struct	ddrawinfot
{
		i32 screensizex;  // Horizontal resolution
		i32 screensizey;  // Vertical resolution
		i32 flwindow;  // Flag window mode
  HWND ddrawwinh;  // Associated with DDraw window handle  
		i32 flddrawwait;  // Flag waiting for synchronization
  i32 flsystemmemory;  // Flag of using system memory for back buffer. For test purpose only.
		i32 bpp; // Bits per pixel
};
typedef ddrawinfot* ddrawinfopt;
#pragma pack(pop)

#pragma pack(push,4)
struct ddrawwindowinfot
{
  i32 destx1,desty1,destx2,desty2;
  i32 soursex1,soursey1,soursex2,soursey2;
  w32 backsurfp;
};
typedef ddrawwindowinfot* ddrawwindowinfopt;
#pragma pack(pop)

#pragma pack(push,4)
struct videomodeinfot
{
  i32 width;
  i32 height;
  i32 bpp;
  i32 refreshrate;
};
typedef videomodeinfot* videomodeinfopt;
typedef videomodeinfopt* videomodeinfoppt;
#pragma pack(pop)

class DDrawObj
{
  public:

  virtual bool callconv flip(w32 surfp, bool flwait)=0;
  virtual w32 callconv getsurfacep()=0;
  virtual i32 callconv getsurfacewpitch()=0;
  virtual bool callconv initpaint(w32 surfp, bool flwait, bool flnosyslock)=0;
  virtual bool callconv donepaint(w32 surfp)=0;
  virtual HDC	callconv getdc(w32 surfp)=0;
  virtual bool	callconv releasedc(w32 surfp, HDC dc)=0;
  virtual bool callconv clear(w32 surfp)=0;
  virtual bool callconv init(HWND hwnd,i32 w,i32 h,i32 bpp, bool flsystemmemory)=0;
  virtual bool callconv done()=0;

  virtual bool callconv drawscreen()=0;  // flip or copy back surface to front 
  virtual bool callconv drawwindow(ddrawwindowinfot info)=0;
  virtual w32 callconv getprimarysurface()=0;
  virtual w32 callconv getbacksurface()=0;
  virtual bool callconv setwindow(HWND hwnd)=0;
  virtual w32 callconv createwindowsurface()=0;
  virtual bool callconv destroywindowsurface(w32 surfp)=0;
  virtual i32 callconv getvideomodes(videomodeinfot** videomodes)=0;
  virtual bool callconv create(ddrawinfot initddrawinfo)=0;  // Initialization the Direct Draw and setting video mode
  virtual bool callconv destroy()=0;  // Releasing Direct Draw
};
typedef DDrawObj* DDrawObjpt;

//=====================================================================

#pragma pack(push,4)
struct dinputinfot
{
  char keys[260];
  long int	mousex,mousey,mousez;
  long int mousedx,mousedy,mousedz;
  long int mousebut0,mousebut1,mousebut2,mousebut3;
};
typedef dinputinfot* dinputinfopt;
#pragma pack(pop)

class DirectInputObj
{
  public:

  virtual bool callconv directinput(dinputinfot* dinputp)=0;
  virtual bool callconv init(bool fldinputmouse)=0;
  virtual bool callconv done()=0;
  virtual bool callconv create(HWND winh)=0;
  virtual bool callconv destroy()=0;
};
typedef DirectInputObj* DirectInputObjpt;

//=====================================================================

#define SEError_NoError               0
#define SEError_OutOfMemory           1
#define SEError_RenderingException    2
#define SEError_PreRenderingException 3
#define SEError_DDrawError            4

class SphericalEngineObj
{
  public:

  virtual SceneObj* callconv allocatescene(bool flsurface, i32 apprspherequ=256, i32 apprentityqu=16)=0;  

  virtual TexturerObj* callconv allocatetexturer(i16 maxtexturetypenum)=0;

  virtual RenderObj* callconv allocaterender(i32 apprspherequ=256)=0;

  virtual void callconv setpixelformat(pixelformatt pixelformat)=0;

  virtual DDrawObj* callconv ddraw()=0;  
  virtual DirectInputObj* callconv dinput()=0;

  virtual bool callconv SSEsupport()=0;  // Detection processor's SSE support
  virtual bool callconv MMXEXTsupport()=0;  // Detection processor's MMXEXTENSIONS support

  virtual i32 callconv getlasterror()=0;

  virtual i32 callconv getversion()=0;  // Engine's version

  virtual bool callconv activate(i32 apprvisiblespherequ=1024)=0;  // Engine's initialization
  virtual void callconv deactivate()=0;  // Engines's deactivation
};
typedef SphericalEngineObj* SphericalEngineObjpt;

typedef SphericalEngineObj* callconv SphericalEngineObjProct();
typedef SphericalEngineObjProct* SphericalEngineObjProcpt;

//=====================================================================

se_api SphericalEngineObj* callconv SphericalEngine();  // Returning pointer to engine's interface object


#undef	se_api


#ifndef spherical_engine_dll

#define sphereobj SphereObj
#define sphereobjpt SphereObjpt
#define lightobj LightObj
#define lightobjpt LightObjpt
#define sphereholderobj SphereHolderObj
#define sphereholderobjpt SphereHolderObjpt
#define entityobj EntityObj
#define entityobjpt EntityObjpt
//#define sceneobj SceneObj
//#define sceneobjpt SceneObjpt
#define texturerobj TexturerObj
#define texturerobjpt TexturerObjpt
#define renderobj RenderObj
#define renderobjpt RenderObjpt
#define ddrawobj DDrawObj
#define ddrawobjpt DDrawObjpt
#define directinputobj DirectInputObj
#define directinputobjpt DirectInputObjpt
#define sphericalengineobj SphericalEngineObj
#define sphericalengineobjpt SphericalEngineObjpt

#endif


//#pragma pack(pop)


#endif