506 lines
14 KiB
C++
506 lines
14 KiB
C++
|
|
#ifndef _TRACK_H_
|
|
#define _TRACK_H_
|
|
|
|
#include "DEFINES.H"
|
|
|
|
#include <Windows.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "CC_alloc.h"
|
|
#include "fileIO.h"
|
|
#include <memory.h>
|
|
#include <MATH.H>
|
|
#include <string.h>
|
|
|
|
|
|
#ifndef __DEFINE_NUMS__
|
|
#define __DEFINE_NUMS__
|
|
|
|
#define f32 float
|
|
#define u32 unsigned int
|
|
#define s32 int
|
|
#define u16 unsigned short
|
|
#define s16 signed short
|
|
#define u8 unsigned char
|
|
#define s8 char
|
|
|
|
#endif
|
|
|
|
#include "TOOLS.h"
|
|
|
|
|
|
inline void *ZeroAlloc(u32 Size)
|
|
{
|
|
void *Ret;
|
|
Ret = CC_malloc(Size);
|
|
memset(Ret,0,Size);
|
|
return Ret;
|
|
}
|
|
|
|
inline void *ZeroRealloc(void* ptr, u32 Size)
|
|
{
|
|
void *Ret;
|
|
Ret = CC_realloc(ptr, Size);
|
|
memset(Ret,0,Size);
|
|
return Ret;
|
|
}
|
|
|
|
|
|
/* Draw functions */
|
|
typedef struct DrwTEXT_UI_ {
|
|
s32 X,Y;
|
|
s32 XEnd,YEnd;
|
|
s32 CursorPosX,CursorPosY;
|
|
u32 CursorPos,CursorPosUP,CursorPosDown;
|
|
u32 CurrentCursorPos;
|
|
u32 SelStart,SelEnd;
|
|
u32 ColorFront,ColorBack;
|
|
s32 MouseX,MouseY,MouseToCursor;
|
|
u32 Birth;
|
|
u32 Age;
|
|
u32 InsertMode;
|
|
u32 DontDraw;
|
|
u32 HCenter;
|
|
u32 ModePassword;
|
|
SIZE *FONT_CharBounds;
|
|
SIZE *FONT_CharPos;
|
|
MAP *FONT_Image;
|
|
u32 FONT_AlphaMode;
|
|
TEXTMETRIC *FONT_Metrix;
|
|
} DrwTEXT_UI;
|
|
|
|
void DRawTEXT_UserInterface(unsigned char *pTEXT,u32 *pBase,s32 Pitch , u32 Height , DrwTEXT_UI *DUI);
|
|
void DRawTEXT_Soft_B(unsigned char *pTEXT,u32 *pBase,u32 X, u32 Y, s32 Pitch , u32 Height , u32 Color);
|
|
void DRawTEXT_Soft_B(unsigned char *pTEXT,u32 *pBase,u32 X, u32 Y, s32 Pitch , u32 Height , u32 Color);
|
|
void DRawTEXT_Soft_B2x(unsigned char *pTEXT,u32 *pBase,u32 X, u32 Y, s32 Pitch , u32 Height , u32 Color);
|
|
void DRawTEXT_Soft_B_Centered(u8 *pTEXT,u32 *pBase,s32 Pitch , u32 Height , u32 Color);
|
|
|
|
|
|
|
|
#define ARGB2ABGR(color) ((color & 0xFF000000) | ((color & 0xFF0000)>>16) | (color & 0xFF00) | ((color & 0xFF)<<16))
|
|
|
|
class Color4
|
|
{
|
|
public:
|
|
union
|
|
{
|
|
float m_tab[4];
|
|
struct
|
|
{
|
|
float m_a;
|
|
float m_r;
|
|
float m_g;
|
|
float m_b;
|
|
};
|
|
};
|
|
|
|
Color4()
|
|
{
|
|
m_a = 1.f;
|
|
m_r = 1.f;
|
|
m_g = 1.f;
|
|
m_b = 1.f;
|
|
}
|
|
Color4(u32 _color) {
|
|
fromU32(_color);
|
|
}
|
|
|
|
Color4(float _a, float _r, float _g, float _b) { m_a = _a; m_r = _r; m_g = _g; m_b = _b; }
|
|
void fromU32(u32 _color)
|
|
{
|
|
m_a = (float)((_color >> 24) & 0xff) / 255.f;
|
|
m_r = (float)((_color >> 16) & 0xff) / 255.f;
|
|
m_g = (float)((_color >> 8) & 0xff) / 255.f;
|
|
m_b = (float)((_color ) & 0xff) / 255.f;
|
|
}
|
|
u32 toU32Color() {
|
|
u32 finalColor = 0;
|
|
f32 tmpColor;
|
|
tmpColor = m_a * 255.f;
|
|
if (tmpColor > 255.f) tmpColor = 255.f;
|
|
if (tmpColor < 0.f) tmpColor = 0.f;
|
|
finalColor = finalColor << 8 | (u32)tmpColor;
|
|
tmpColor = m_r * 255.f;
|
|
if (tmpColor > 255.f) tmpColor = 255.f;
|
|
if (tmpColor < 0.f) tmpColor = 0.f;
|
|
finalColor = finalColor << 8 | (u32)tmpColor;
|
|
tmpColor = m_g * 255.f;
|
|
if (tmpColor > 255.f) tmpColor = 255.f;
|
|
if (tmpColor < 0.f) tmpColor = 0.f;
|
|
finalColor = finalColor << 8 | (u32)tmpColor;
|
|
tmpColor = m_b * 255.f;
|
|
if (tmpColor > 255.f) tmpColor = 255.f;
|
|
if (tmpColor < 0.f) tmpColor = 0.f;
|
|
finalColor = finalColor << 8 | (u32)tmpColor;
|
|
return finalColor;
|
|
}
|
|
|
|
float & operator[] (u32 _index) { return m_tab[_index]; }
|
|
Color4 operator+ (Color4 _color) { return Color4(m_a + _color.m_a, m_r + _color.m_r,m_g + _color.m_g,m_b + _color.m_b); }
|
|
Color4 operator+= (Color4 _color) {
|
|
m_a+=_color.m_a;
|
|
m_r+=_color.m_r;
|
|
m_g+=_color.m_g;
|
|
m_b+=_color.m_b;
|
|
return *this;
|
|
}
|
|
Color4 operator- (Color4 _color) { return Color4(m_a - _color.m_a, m_r - _color.m_r,m_g - _color.m_g,m_b - _color.m_b); }
|
|
Color4 operator-= (Color4 _color) {
|
|
m_a-=_color.m_a;
|
|
m_r-=_color.m_r;
|
|
m_g-=_color.m_g;
|
|
m_b-=_color.m_b;
|
|
return *this;
|
|
}
|
|
Color4 operator* (f32 val) { return Color4(m_a*val,m_r*val,m_g*val,m_b*val); }
|
|
|
|
};
|
|
|
|
typedef struct RS_
|
|
{
|
|
u8 LIGHTED:1;
|
|
u8 WIRED:1;
|
|
u8 BACKFACE:1;
|
|
u8 BACKFACE_INVERT:1;
|
|
u8 NOZWRITE:1;
|
|
u8 NOZTEST:1;
|
|
u8 TEXTURED:1;
|
|
u8 HIDECOLOR:1;
|
|
u8 HIDEALPHA:1;
|
|
u8 SECONDPASS:1;
|
|
u8 INVERTALPHA:1;
|
|
u8 PICKABLE:1;
|
|
u8 SKIPLAYER:1;
|
|
u8 TEXTUREREPEAT_U:1;
|
|
u8 TEXTUREREPEAT_V:1;
|
|
u8 PICKABLE_NO_TRANSPARENCY:1;
|
|
u8 ZEQUAL:1;
|
|
u8 ZPASS:1;
|
|
u8 USEVERTEXCOLORS:1;
|
|
u8 TEXTUREBILINEAR:1;
|
|
/*
|
|
UV MATRIX | 0 1 |
|
|
| 2 3 |
|
|
translation [ 4 5 ]
|
|
*/
|
|
float UVMATRIX[6];
|
|
#define BLENDING_MODES "BLENDING MODES: 0=COPY;1=ALPHA;2=ADD;3=ALPHA PREMULT;4=PREVIOUS ALPHA;5=Multiply;6=Multiply Invert;7=Multiply x 2"
|
|
#define MAPPING_MODES "MAPPING MODES: 0=OBJECT;1=CHROME;2=PLANAR Z;3=PLANAR SCRENN;4=OBJECT UV2"
|
|
u8 BlendingMode;
|
|
u8 MappingMode;
|
|
u8 AlphaThreshold;
|
|
float NormalExtraction;
|
|
|
|
/// animation on textures
|
|
u16 AnimNbX;
|
|
u16 AnimNbY;
|
|
float AnimFPS;
|
|
DWORD AnimTime;
|
|
} RS;
|
|
|
|
_inline void GLOB_SetDefaultRS(RS *RenderMode)
|
|
{
|
|
RenderMode->WIRED = 0;
|
|
RenderMode->LIGHTED = 0;
|
|
RenderMode->BACKFACE = 1;
|
|
RenderMode->BACKFACE_INVERT = 0;
|
|
RenderMode->NOZWRITE = 0;
|
|
RenderMode->ZEQUAL = 0;
|
|
RenderMode->ZPASS = 0;
|
|
RenderMode->NOZTEST = 0;
|
|
RenderMode->TEXTURED = 1;
|
|
RenderMode->HIDECOLOR = 0;
|
|
RenderMode->HIDEALPHA = 0;
|
|
RenderMode->SECONDPASS = 0;
|
|
RenderMode->INVERTALPHA = 0;
|
|
RenderMode->PICKABLE = 1;
|
|
RenderMode->PICKABLE_NO_TRANSPARENCY = 0;
|
|
RenderMode->SKIPLAYER = 0;
|
|
RenderMode->TEXTUREREPEAT_U = 1;
|
|
RenderMode->TEXTUREREPEAT_V = 1;
|
|
RenderMode->UVMATRIX[0] = RenderMode->UVMATRIX[3] = 1;
|
|
RenderMode->UVMATRIX[1] = RenderMode->UVMATRIX[2] =
|
|
RenderMode->UVMATRIX[4] = RenderMode->UVMATRIX[5] = 0;
|
|
RenderMode->BlendingMode = 0 /* Copy */;
|
|
RenderMode->MappingMode = 0 /* Copy */;
|
|
RenderMode->AlphaThreshold = 0;
|
|
RenderMode->NormalExtraction = 0.0f;
|
|
RenderMode->USEVERTEXCOLORS = 0;
|
|
RenderMode->TEXTUREBILINEAR = 1;
|
|
|
|
RenderMode->AnimNbX = 1;
|
|
RenderMode->AnimNbY = 1;
|
|
RenderMode->AnimFPS = 0.0f;
|
|
RenderMode->AnimTime= 0;
|
|
};
|
|
|
|
#define MAX_LIGHT 20
|
|
#define MAX_BROCH 20
|
|
|
|
typedef struct Light_
|
|
{
|
|
struct _3D_Light_ *LightDesc;
|
|
Vector Position;
|
|
Vector Direction;
|
|
} Light;
|
|
|
|
|
|
typedef struct OPENGL_TEXTURE_
|
|
{
|
|
MAP *pExtRef;
|
|
u32 OGLRef; // -1 mean notexture
|
|
u32 ColorMode; // 0 = RGBA ; 1 = BW
|
|
u32 ClampMode; // 1 = clamp U , 2 = clamp V , 3 clamp UV
|
|
u32 CacheCounter;
|
|
u32 LayerIndex; // -1 mean not a layered texture
|
|
u32 LastHash;
|
|
u32 IsMipMapped;
|
|
} OPENGL_TEXTURE;
|
|
#define MaxOglTexture 2048
|
|
//#define MaxOglTexture 4096
|
|
|
|
#define NUMBER_OF_WORKING_REF 12
|
|
class DrawInterface
|
|
{
|
|
public:
|
|
u32 FORCE_RENDER_FLAG;
|
|
u32 PickingEnable;
|
|
Vector MousePicking;
|
|
Vector MousePickingXYZ;
|
|
Vector MousePickingUVW;
|
|
u32 MousePickingTri;
|
|
float MousePickingCurrentZ;
|
|
MAP *pPickedTexture;
|
|
class WORLD *MotherClass;
|
|
Light AllLight[MAX_LIGHT];
|
|
u32 AllLightNumber;//*/
|
|
void *pComputingBuffer;
|
|
u32 ComputingBufferSize;
|
|
float ComputeMaskAlpha;
|
|
u32 OptimiseQuadRender;
|
|
|
|
u32 FB_SX,FB_SY;
|
|
u32 CurrentColor;
|
|
|
|
u32 QuadRotation_ON;
|
|
MATRIX QuadRotationMatrix;
|
|
float QuadRotation_Focale;
|
|
float QuadUVMatrix[4]; // X,Y,W,H
|
|
Vector QuadDisplace;
|
|
u32 QuadHideColor;
|
|
|
|
float CurrentViewport[4];
|
|
float SavedCurrentViewport[4];
|
|
float ZBIas;
|
|
float ZQuad;
|
|
|
|
|
|
s32 RenderTargetBaseX;
|
|
s32 RenderTargetBaseY;
|
|
u32 RenderTargetState;
|
|
u32 OGLTextureSizeX;
|
|
u32 OGLTextureSizeY;
|
|
|
|
u32 RectifyTextOrigin;
|
|
|
|
|
|
RECT ActivRect;
|
|
RECT ScissorRect;
|
|
|
|
|
|
HWND OpenglDisplayer; // Local Window
|
|
|
|
OPENGL_TEXTURE AllRef[MaxOglTexture];
|
|
RS CurrentRS;
|
|
RS LastRS;
|
|
u32 ulNumberOfTexture;
|
|
u32 ulCurrentTexture;
|
|
HDC hDC;
|
|
HGLRC hRC;
|
|
HWND CurrenthWnd;
|
|
RECT CurrentRect;
|
|
RECT hDCRect;
|
|
float fFocUsed;
|
|
#define NUMBER_OF_OGL_WORKING_REF NUMBER_OF_WORKING_REF
|
|
u32 OGLWorkingRef[NUMBER_OF_OGL_WORKING_REF];
|
|
u32 IsVisible;
|
|
|
|
|
|
void AddALight(struct _3D_Light_ *pLight,Vector *Position,Vector *Direction)
|
|
{
|
|
if (AllLightNumber < MAX_LIGHT)
|
|
{
|
|
AllLight[AllLightNumber].LightDesc = pLight;
|
|
AllLight[AllLightNumber].Position = *Position;
|
|
AllLight[AllLightNumber].Direction = *Direction;
|
|
AllLightNumber++;
|
|
};
|
|
};
|
|
void ClearLight()
|
|
{
|
|
AllLightNumber = 0;
|
|
};
|
|
|
|
virtual void Begin(RECT *HdcRect) = 0;
|
|
virtual void End() = 0;
|
|
virtual void Flush() = 0;
|
|
|
|
virtual void Perspective(float FocaleLenght) = 0;
|
|
virtual void Holographic(Vector *pUserpos,float WindowWith) = 0;
|
|
virtual void Ortho() = 0;
|
|
virtual void Flip(s32 ShowMe) = 0;
|
|
|
|
virtual void Clear(u32 Color) = 0;
|
|
virtual void ClearZ() = 0;
|
|
|
|
virtual void Matrix(MATRIX *MatrixToSet) = 0;
|
|
virtual void RenderMesh(Mesh *pMyMesh,u32 Num, u32 Base) = 0;
|
|
void RenderMesh(Mesh *pMyMesh) {RenderMesh(pMyMesh,pMyMesh->NumberOfFaces,0);};
|
|
virtual void ReverseRenderMesh(Mesh *pMyMesh,u32 TextureSource,u32 Num, u32 Base) = 0;
|
|
void ReverseRenderMesh(Mesh *pMyMesh,u32 TextureSource) {ReverseRenderMesh(pMyMesh,TextureSource,pMyMesh->NumberOfFaces,0);};
|
|
|
|
virtual void SetRS(RS *RenderMode,u32 TextureIndex) = 0;
|
|
virtual void DrawQuad(u32 Color,float X, float Y,float Xsize, float Ysize,float TX,float TY,float TW,float TH) = 0;
|
|
void DrawCircle(u32 TextureIndex,Vector *Center, float InnerRadius, float OuterRadius, float ClockDegreeStart,float ClockDegreeEnd,RS *RenderState);
|
|
void DrawPatch32(u32 TextureIndex,Vector *Point, Color4*Colors, u32 drawHalf,u32 NumberOfCurves,u32 HDIV, u32 VDIV,RS *RenderState);
|
|
|
|
|
|
virtual void SetCurrentColor(u32 Color) = 0;
|
|
virtual u32 GetCurrentColor() {return 0xffffffff;};
|
|
|
|
virtual void ReadFrameBuffer(s32 X,s32 Y,s32 SX,s32 SY, MAP *dest) = 0;
|
|
|
|
/* Texture management */
|
|
virtual u32 CreateTexture(MAP *pExternalReferenceRGBA,u32 Colormode, bool forceCreation = false) {return (u32)-1;};
|
|
virtual u32 CreateLayerTexture(MAP *pExternalReferenceRGBA,u32 LayerIndex) = 0;
|
|
virtual void DestroyLayerTexture(u32 TextureIndex) = 0;
|
|
|
|
virtual void SetTextureColorMode(u32 Index,u32 ColorMode) = 0;
|
|
virtual void UpdateTexture_BM_2_HW(u32 TextureIndex, bool isDynmaic = true) = 0;
|
|
virtual void UpdateTexture_HW_2_BM(u32 TextureIndex,u32 UpdateSoftBuffer) = 0;
|
|
virtual void UpdateTexture_HW_2_BM(u32 TextureIndex,u32 UpdateSoftBuffer,s32 SourceX,s32 SourceY) = 0;
|
|
|
|
virtual void DestroyTexture(u32 TextureIndex) = 0;
|
|
void SetBackGround(u32 TextureIndex,u32 Blend = 0);
|
|
void DrawQuad(u32 TextureIndex,s32 XMin,s32 XMax,s32 YMin,s32 YMax,RS *RenderMode = NULL);
|
|
void DrawQuadDistord(u32 TextureIndex,s32 XMin,s32 XMax,s32 YMin,s32 YMax,RS *RenderMode = NULL);
|
|
void DrawCenteredQuad(u32 Color,float Xsize, float Ysize, float FX,float FY);
|
|
|
|
void Process2DProjection();
|
|
void Process2DRotation(u8 begin, s32 bnd0X = 0, s32 bnd1X = 0, s32 bnd0Y = 0, s32 bnd1Y = 0);
|
|
|
|
void DrawMultipleQuads(u32 TextureIndex,u32 Number,s32 *Bounds,float *BoundsUV,RS *RenderState = NULL);
|
|
void Draw2DLine(u32 TextureIndex, Vector *A, Vector *B, int Lenght, RS *RenderState = NULL);
|
|
virtual void DrawLine(u32 Color,Vector *A,Vector *B, int Lenght = 0) = 0;
|
|
|
|
void SetQuadHideColorAlpha(int C,int A);
|
|
void SetQuadRot(float Focale , Vector *pAxisAngle , Vector *pCenter);
|
|
void SetQuadDisplace(Vector *pDisplace);
|
|
void SetQuadUVSource(float BasU,float BasV,float WU,float WV);
|
|
void SetQuadDefault();
|
|
|
|
virtual void Setexture(u32 TextureIndex,float *UVMatrix = NULL) = 0;
|
|
virtual void SetFog(u32 OnOff,float Near , float far , u32 Color) = 0;
|
|
|
|
virtual void BeginTextureTarget(u32 TextureIndex,u32 SaveFrontBuffer = 0) = 0;
|
|
virtual void EndTextureTarget(u32 TextureIndex,u32 bUpdateSoftBuffer) = 0;
|
|
|
|
virtual void ChangeMode(HWND Mother, bool UseGDI) = 0;
|
|
virtual void SetResolution(u32 X,u32 SY) = 0;
|
|
virtual void SetViewport(s32 X,s32 Y,s32 SX,s32 SY) = 0;
|
|
void GetViewport(s32 *X,s32 *Y,s32 *SX,s32 *SY)
|
|
{
|
|
*X = s32(CurrentViewport[0]) ;
|
|
*Y = s32(CurrentViewport[1]) ;
|
|
*SX = s32(CurrentViewport[2]) ;
|
|
*SY = s32(CurrentViewport[3]) ;
|
|
}
|
|
|
|
virtual void SetClipping(s32 X,s32 Y,s32 SX,s32 SY) = 0;
|
|
virtual void AfterEffect(u32 ulType,u32 Color,float Factor1,float Factor2,float Factor3 = 0.0f,float Factor4 = 0.0f,float Factor5 = 0.0f) = 0;
|
|
virtual void LayerOperation(u32 ulType,u32 SlotIndex,u32 Color,float Factor1,float Factor2) = 0;
|
|
|
|
/* Picking */
|
|
void Mul4x4Matrix(float *M1,float *M2,float *MR);
|
|
void PickMesh(Mesh *pMyMesh,u32 Num, u32 Base);
|
|
void PickQuad(u32 Color,float X, float Y,float Xsize, float Ysize,float TX,float TY,float TW,float TH);
|
|
void PickQuadGone(u32 Color,Vector *XYZ, Vector *UV);
|
|
|
|
/* Text */
|
|
u32 FontTextureIndex;
|
|
MAP FontMap;
|
|
|
|
void init_font(void);
|
|
void DrawText(unsigned char *Txt,float X, float Y, float FX, float FY , u32 ColorRGBA , u32 DrawModeShadow = 1);
|
|
void DrawTextCentered(unsigned char *pTEXT,u32 Color);
|
|
void RenderText(unsigned char *Txt,float X, float Y, float FX, float FY , u32 ColorRGBA, MAP *fontMap, int TextureIdx, SIZE *CharPos, SIZE *CharBounds, u32 optionMask, int blendingMode = -1);
|
|
void GetTextSize(unsigned char *Txt,s32 *DX,s32 *DY, SIZE *CharBounds = NULL);
|
|
|
|
/* Win32 */
|
|
virtual void Destroy() = 0; // Destroy
|
|
virtual void AdaptTOWindow(HWND hWnd) = 0;
|
|
|
|
virtual void DrawParticules(void *particuleList, int nbParticules, u32 TextureIndex, SIZE grid,RS *RenderState, MATRIX Orientation) = 0;
|
|
virtual void DrawFur(void *fur, u32 TextureIndex,RS *RenderState, MATRIX Orientation, u32 debug) = 0;
|
|
/* Matrix Overloadd */
|
|
/* 0 = Projection , 1 = Model , 2 = Texture */
|
|
virtual void GetMatrix(u32 Mode,float *pDest) = 0;
|
|
virtual void SetMatrix(u32 Mode,float *pDest) = 0;
|
|
|
|
|
|
virtual u32 GetDriverType() = 0; // "opengl" = 0 , 'D3D' = 1
|
|
};
|
|
|
|
DrawInterface *CreateOglObject(HWND Mother,u32 FrameBuffSizeX,u32 FrameBuffSizeY);
|
|
DrawInterface *CreateD3DObject(HWND Mother,u32 FrameBuffSizeX,u32 FrameBuffSizeY);
|
|
DrawInterface *CreateNulObject(HWND Mother,u32 FrameBuffSizeX,u32 FrameBuffSizeY);
|
|
|
|
|
|
/* TOOLS */
|
|
u32 GetFileLenght(char *Filename);
|
|
u32 IsExist(char *Filename);
|
|
class INPUT_IO *CreateIO(class WORLD *,char *MediaName, bool dummy = false);
|
|
class INPUT_IO *ERROR_CREATE(char *Error);
|
|
u32 GetBitReverse(u32 Value); // Transform 0x80000000 into 0x00000001
|
|
u32 GetBitExpand(u32 Value); // Transform 0xFFFF into 0x55555555
|
|
u32 GetBitContract(u32 Value); // Transform 0x55555555 into 0xFFFF
|
|
|
|
int GetLogUpperPO2(float Value);
|
|
int GetUpperPO2(float Value);
|
|
int GetFirstBit(u32 Mask);
|
|
|
|
|
|
|
|
#define SAVE_MATRIXES()\
|
|
float _4x4_Persp[16];\
|
|
float _4x4_Model[16];\
|
|
float _4x4_Texture[16];\
|
|
float FocalSave;\
|
|
GetMatrix(0, _4x4_Persp);\
|
|
GetMatrix(1, _4x4_Model);\
|
|
GetMatrix(2, _4x4_Texture);\
|
|
FocalSave = fFocUsed;
|
|
|
|
#define RESTORE_MATRIXES()\
|
|
fFocUsed = FocalSave;\
|
|
SetMatrix(0, _4x4_Persp);\
|
|
SetMatrix(1, _4x4_Model);\
|
|
SetMatrix(2, _4x4_Texture);
|
|
|
|
|
|
#define TYPE_Of_PREC float
|
|
|
|
typedef struct FFT_Complex_
|
|
{
|
|
TYPE_Of_PREC re,im;
|
|
} FFT_Complex;
|
|
|
|
void FFT2Image(int *Picture,void *FFT,int Pitch);
|
|
void *Image2FFT(int *Picture,int SizePo2,int Pitch);
|
|
|
|
void PatchPointsToNormals(Vector *pCurves, Color4 *dstColors, u32 *srColors, int invert);
|
|
Vector PatchGetXYZFromUV(Vector *pCurves, Vector UV);
|
|
Vector PatchGetUVFromXYZ(Vector *pCurves, Vector Point, Vector vMin, Vector vMax);
|
|
|
|
#endif
|