892 lines
22 KiB
C++
892 lines
22 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2016, assimp team
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the
|
|
following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
----------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file BlenderScene.h
|
|
* @brief Intermediate representation of a BLEND scene.
|
|
*/
|
|
#ifndef INCLUDED_AI_BLEND_SCENE_H
|
|
#define INCLUDED_AI_BLEND_SCENE_H
|
|
|
|
#include "BlenderDNA.h"
|
|
|
|
namespace Assimp {
|
|
namespace Blender {
|
|
|
|
// Minor parts of this file are extracts from blender data structures,
|
|
// declared in the ./source/blender/makesdna directory.
|
|
// Stuff that is not used by Assimp is commented.
|
|
|
|
|
|
// NOTE
|
|
// this file serves as input data to the `./scripts/genblenddna.py`
|
|
// script. This script generates the actual binding code to read a
|
|
// blender file with a possibly different DNA into our structures.
|
|
// Only `struct` declarations are considered and the following
|
|
// rules must be obeyed in order for the script to work properly:
|
|
//
|
|
// * C++ style comments only
|
|
//
|
|
// * Structures may include the primitive types char, int, short,
|
|
// float, double. Signed specifiers are not allowed on
|
|
// integers. Enum types are allowed, but they must have been
|
|
// defined in this header.
|
|
//
|
|
// * Structures may aggregate other structures, unless not defined
|
|
// in this header.
|
|
//
|
|
// * Pointers to other structures or primitive types are allowed.
|
|
// No references or double pointers or arrays of pointers.
|
|
// A pointer to a T is normally written as std::shared_ptr, while a
|
|
// pointer to an array of elements is written as boost::
|
|
// shared_array. To avoid cyclic pointers, use raw pointers in
|
|
// one direction.
|
|
//
|
|
// * Arrays can have maximally two-dimensions. Any non-pointer
|
|
// type can form them.
|
|
//
|
|
// * Multiple fields can be declare in a single line (i.e `int a,b;`)
|
|
// provided they are neither pointers nor arrays.
|
|
//
|
|
// * One of WARN, FAIL can be appended to the declaration (
|
|
// prior to the semicolon to specify the error handling policy if
|
|
// this field is missing in the input DNA). If none of those
|
|
// is specified the default policy is to substitute a default
|
|
// value for the field.
|
|
//
|
|
|
|
// warn if field is missing, substitute default value
|
|
#ifdef WARN
|
|
# undef WARN
|
|
#endif
|
|
#define WARN
|
|
|
|
// fail the import if the field does not exist
|
|
#ifdef FAIL
|
|
# undef FAIL
|
|
#endif
|
|
#define FAIL
|
|
|
|
struct Object;
|
|
struct MTex;
|
|
struct Image;
|
|
|
|
#include <memory>
|
|
|
|
#define AI_BLEND_MESH_MAX_VERTS 2000000000L
|
|
|
|
static const size_t MaxNameLen = 1024;
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct ID : ElemBase {
|
|
char name[ MaxNameLen ] WARN;
|
|
short flag;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct ListBase : ElemBase {
|
|
std::shared_ptr<ElemBase> first;
|
|
std::shared_ptr<ElemBase> last;
|
|
};
|
|
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct PackedFile : ElemBase {
|
|
int size WARN;
|
|
int seek WARN;
|
|
std::shared_ptr< FileOffset > data WARN;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct GroupObject : ElemBase {
|
|
std::shared_ptr<GroupObject> prev,next FAIL;
|
|
std::shared_ptr<Object> ob;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Group : ElemBase {
|
|
ID id FAIL;
|
|
int layer;
|
|
|
|
std::shared_ptr<GroupObject> gobject;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct World : ElemBase {
|
|
ID id FAIL;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MVert : ElemBase {
|
|
float co[3] FAIL;
|
|
float no[3] FAIL;
|
|
char flag;
|
|
int mat_nr WARN;
|
|
int bweight;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MEdge : ElemBase {
|
|
int v1, v2 FAIL;
|
|
char crease, bweight;
|
|
short flag;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MLoop : ElemBase {
|
|
int v, e;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MLoopUV : ElemBase {
|
|
float uv[2];
|
|
int flag;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
// Note that red and blue are not swapped, as with MCol
|
|
struct MLoopCol : ElemBase {
|
|
unsigned char r, g, b, a;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MPoly : ElemBase {
|
|
int loopstart;
|
|
int totloop;
|
|
short mat_nr;
|
|
char flag;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MTexPoly : ElemBase {
|
|
Image* tpage;
|
|
char flag, transp;
|
|
short mode, tile, pad;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MCol : ElemBase {
|
|
char r,g,b,a FAIL;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MFace : ElemBase {
|
|
int v1,v2,v3,v4 FAIL;
|
|
int mat_nr FAIL;
|
|
char flag;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct TFace : ElemBase {
|
|
float uv[4][2] FAIL;
|
|
int col[4] FAIL;
|
|
char flag;
|
|
short mode;
|
|
short tile;
|
|
short unwrap;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MTFace : ElemBase {
|
|
float uv[4][2] FAIL;
|
|
char flag;
|
|
short mode;
|
|
short tile;
|
|
short unwrap;
|
|
|
|
// std::shared_ptr<Image> tpage;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MDeformWeight : ElemBase {
|
|
int def_nr FAIL;
|
|
float weight FAIL;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MDeformVert : ElemBase {
|
|
vector<MDeformWeight> dw WARN;
|
|
int totweight;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
#define MA_RAYMIRROR 0x40000
|
|
#define MA_TRANSPARENCY 0x10000
|
|
#define MA_RAYTRANSP 0x20000
|
|
#define MA_ZTRANSP 0x00040
|
|
|
|
struct Material : ElemBase {
|
|
ID id FAIL;
|
|
|
|
float r,g,b WARN;
|
|
float specr,specg,specb WARN;
|
|
short har;
|
|
float ambr,ambg,ambb WARN;
|
|
float mirr,mirg,mirb;
|
|
float emit WARN;
|
|
float ray_mirror;
|
|
float alpha WARN;
|
|
float ref;
|
|
float translucency;
|
|
int mode;
|
|
float roughness;
|
|
float darkness;
|
|
float refrac;
|
|
|
|
float amb;
|
|
float ang;
|
|
float spectra;
|
|
float spec;
|
|
float zoffs;
|
|
float add;
|
|
float fresnel_mir;
|
|
float fresnel_mir_i;
|
|
float fresnel_tra;
|
|
float fresnel_tra_i;
|
|
float filter;
|
|
float tx_limit;
|
|
float tx_falloff;
|
|
float gloss_mir;
|
|
float gloss_tra;
|
|
float adapt_thresh_mir;
|
|
float adapt_thresh_tra;
|
|
float aniso_gloss_mir;
|
|
float dist_mir;
|
|
float hasize;
|
|
float flaresize;
|
|
float subsize;
|
|
float flareboost;
|
|
float strand_sta;
|
|
float strand_end;
|
|
float strand_ease;
|
|
float strand_surfnor;
|
|
float strand_min;
|
|
float strand_widthfade;
|
|
float sbias;
|
|
float lbias;
|
|
float shad_alpha;
|
|
float param;
|
|
float rms;
|
|
float rampfac_col;
|
|
float rampfac_spec;
|
|
float friction;
|
|
float fh;
|
|
float reflect;
|
|
float fhdist;
|
|
float xyfrict;
|
|
float sss_radius;
|
|
float sss_col;
|
|
float sss_error;
|
|
float sss_scale;
|
|
float sss_ior;
|
|
float sss_colfac;
|
|
float sss_texfac;
|
|
float sss_front;
|
|
float sss_back;
|
|
|
|
short material_type;
|
|
short flag;
|
|
short ray_depth;
|
|
short ray_depth_tra;
|
|
short samp_gloss_mir;
|
|
short samp_gloss_tra;
|
|
short fadeto_mir;
|
|
short shade_flag;
|
|
short flarec;
|
|
short starc;
|
|
short linec;
|
|
short ringc;
|
|
short pr_lamp;
|
|
short pr_texture;
|
|
short ml_flag;
|
|
short texco;
|
|
short mapto;
|
|
short ramp_show;
|
|
short pad3;
|
|
short dynamode;
|
|
short pad2;
|
|
short sss_flag;
|
|
short sss_preset;
|
|
short shadowonly_flag;
|
|
short index;
|
|
short vcol_alpha;
|
|
short pad4;
|
|
|
|
char seed1;
|
|
char seed2;
|
|
|
|
std::shared_ptr<Group> group;
|
|
|
|
short diff_shader WARN;
|
|
short spec_shader WARN;
|
|
|
|
std::shared_ptr<MTex> mtex[18];
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Mesh : ElemBase {
|
|
ID id FAIL;
|
|
|
|
int totface FAIL;
|
|
int totedge FAIL;
|
|
int totvert FAIL;
|
|
int totloop;
|
|
int totpoly;
|
|
|
|
short subdiv;
|
|
short subdivr;
|
|
short subsurftype;
|
|
short smoothresh;
|
|
|
|
vector<MFace> mface FAIL;
|
|
vector<MTFace> mtface;
|
|
vector<TFace> tface;
|
|
vector<MVert> mvert FAIL;
|
|
vector<MEdge> medge WARN;
|
|
vector<MLoop> mloop;
|
|
vector<MLoopUV> mloopuv;
|
|
vector<MLoopCol> mloopcol;
|
|
vector<MPoly> mpoly;
|
|
vector<MTexPoly> mtpoly;
|
|
vector<MDeformVert> dvert;
|
|
vector<MCol> mcol;
|
|
|
|
vector< std::shared_ptr<Material> > mat FAIL;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Library : ElemBase {
|
|
ID id FAIL;
|
|
|
|
char name[240] WARN;
|
|
char filename[240] FAIL;
|
|
std::shared_ptr<Library> parent WARN;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Camera : ElemBase {
|
|
enum Type {
|
|
Type_PERSP = 0
|
|
,Type_ORTHO = 1
|
|
};
|
|
|
|
ID id FAIL;
|
|
|
|
Type type,flag WARN;
|
|
float lens WARN;
|
|
float sensor_x WARN;
|
|
float clipsta, clipend;
|
|
};
|
|
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Lamp : ElemBase {
|
|
|
|
enum FalloffType {
|
|
FalloffType_Constant = 0x0
|
|
,FalloffType_InvLinear = 0x1
|
|
,FalloffType_InvSquare = 0x2
|
|
//,FalloffType_Curve = 0x3
|
|
//,FalloffType_Sliders = 0x4
|
|
};
|
|
|
|
enum Type {
|
|
Type_Local = 0x0
|
|
,Type_Sun = 0x1
|
|
,Type_Spot = 0x2
|
|
,Type_Hemi = 0x3
|
|
,Type_Area = 0x4
|
|
//,Type_YFPhoton = 0x5
|
|
};
|
|
|
|
ID id FAIL;
|
|
//AnimData *adt;
|
|
|
|
Type type FAIL;
|
|
short flags;
|
|
|
|
//int mode;
|
|
|
|
short colormodel, totex;
|
|
float r,g,b,k WARN;
|
|
//float shdwr, shdwg, shdwb;
|
|
|
|
float energy, dist, spotsize, spotblend;
|
|
//float haint;
|
|
|
|
float att1, att2;
|
|
//struct CurveMapping *curfalloff;
|
|
FalloffType falloff_type;
|
|
|
|
//float clipsta, clipend, shadspotsize;
|
|
//float bias, soft, compressthresh;
|
|
//short bufsize, samp, buffers, filtertype;
|
|
//char bufflag, buftype;
|
|
|
|
//short ray_samp, ray_sampy, ray_sampz;
|
|
//short ray_samp_type;
|
|
short area_shape;
|
|
float area_size, area_sizey, area_sizez;
|
|
//float adapt_thresh;
|
|
//short ray_samp_method;
|
|
|
|
//short texact, shadhalostep;
|
|
|
|
//short sun_effect_type;
|
|
//short skyblendtype;
|
|
//float horizon_brightness;
|
|
//float spread;
|
|
float sun_brightness;
|
|
//float sun_size;
|
|
//float backscattered_light;
|
|
//float sun_intensity;
|
|
//float atm_turbidity;
|
|
//float atm_inscattering_factor;
|
|
//float atm_extinction_factor;
|
|
//float atm_distance_factor;
|
|
//float skyblendfac;
|
|
//float sky_exposure;
|
|
//short sky_colorspace;
|
|
|
|
// int YF_numphotons, YF_numsearch;
|
|
// short YF_phdepth, YF_useqmc, YF_bufsize, YF_pad;
|
|
// float YF_causticblur, YF_ltradius;
|
|
|
|
// float YF_glowint, YF_glowofs;
|
|
// short YF_glowtype, YF_pad2;
|
|
|
|
//struct Ipo *ipo;
|
|
//struct MTex *mtex[18];
|
|
// short pr_texture;
|
|
|
|
//struct PreviewImage *preview;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct ModifierData : ElemBase {
|
|
enum ModifierType {
|
|
eModifierType_None = 0,
|
|
eModifierType_Subsurf,
|
|
eModifierType_Lattice,
|
|
eModifierType_Curve,
|
|
eModifierType_Build,
|
|
eModifierType_Mirror,
|
|
eModifierType_Decimate,
|
|
eModifierType_Wave,
|
|
eModifierType_Armature,
|
|
eModifierType_Hook,
|
|
eModifierType_Softbody,
|
|
eModifierType_Boolean,
|
|
eModifierType_Array,
|
|
eModifierType_EdgeSplit,
|
|
eModifierType_Displace,
|
|
eModifierType_UVProject,
|
|
eModifierType_Smooth,
|
|
eModifierType_Cast,
|
|
eModifierType_MeshDeform,
|
|
eModifierType_ParticleSystem,
|
|
eModifierType_ParticleInstance,
|
|
eModifierType_Explode,
|
|
eModifierType_Cloth,
|
|
eModifierType_Collision,
|
|
eModifierType_Bevel,
|
|
eModifierType_Shrinkwrap,
|
|
eModifierType_Fluidsim,
|
|
eModifierType_Mask,
|
|
eModifierType_SimpleDeform,
|
|
eModifierType_Multires,
|
|
eModifierType_Surface,
|
|
eModifierType_Smoke,
|
|
eModifierType_ShapeKey
|
|
};
|
|
|
|
std::shared_ptr<ElemBase> next WARN;
|
|
std::shared_ptr<ElemBase> prev WARN;
|
|
|
|
int type, mode;
|
|
char name[32];
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct SubsurfModifierData : ElemBase {
|
|
|
|
enum Type {
|
|
|
|
TYPE_CatmullClarke = 0x0,
|
|
TYPE_Simple = 0x1
|
|
};
|
|
|
|
enum Flags {
|
|
// some omitted
|
|
FLAGS_SubsurfUV =1<<3
|
|
};
|
|
|
|
ModifierData modifier FAIL;
|
|
short subdivType WARN;
|
|
short levels FAIL;
|
|
short renderLevels ;
|
|
short flags;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MirrorModifierData : ElemBase {
|
|
|
|
enum Flags {
|
|
Flags_CLIPPING =1<<0,
|
|
Flags_MIRROR_U =1<<1,
|
|
Flags_MIRROR_V =1<<2,
|
|
Flags_AXIS_X =1<<3,
|
|
Flags_AXIS_Y =1<<4,
|
|
Flags_AXIS_Z =1<<5,
|
|
Flags_VGROUP =1<<6
|
|
};
|
|
|
|
ModifierData modifier FAIL;
|
|
|
|
short axis, flag;
|
|
float tolerance;
|
|
std::shared_ptr<Object> mirror_ob;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Object : ElemBase {
|
|
ID id FAIL;
|
|
|
|
enum Type {
|
|
Type_EMPTY = 0
|
|
,Type_MESH = 1
|
|
,Type_CURVE = 2
|
|
,Type_SURF = 3
|
|
,Type_FONT = 4
|
|
,Type_MBALL = 5
|
|
|
|
,Type_LAMP = 10
|
|
,Type_CAMERA = 11
|
|
|
|
,Type_WAVE = 21
|
|
,Type_LATTICE = 22
|
|
};
|
|
|
|
Type type FAIL;
|
|
float obmat[4][4] WARN;
|
|
float parentinv[4][4] WARN;
|
|
char parsubstr[32] WARN;
|
|
|
|
Object* parent WARN;
|
|
std::shared_ptr<Object> track WARN;
|
|
|
|
std::shared_ptr<Object> proxy,proxy_from,proxy_group WARN;
|
|
std::shared_ptr<Group> dup_group WARN;
|
|
std::shared_ptr<ElemBase> data FAIL;
|
|
|
|
ListBase modifiers;
|
|
|
|
Object()
|
|
: ElemBase()
|
|
, type( Type_EMPTY )
|
|
, parent( nullptr )
|
|
, track()
|
|
, proxy()
|
|
, proxy_from()
|
|
, data() {
|
|
// empty
|
|
}
|
|
};
|
|
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Base : ElemBase {
|
|
Base* prev WARN;
|
|
std::shared_ptr<Base> next WARN;
|
|
std::shared_ptr<Object> object WARN;
|
|
|
|
Base()
|
|
: ElemBase()
|
|
, prev( nullptr )
|
|
, next()
|
|
, object() {
|
|
// empty
|
|
// empty
|
|
}
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Scene : ElemBase {
|
|
ID id FAIL;
|
|
|
|
std::shared_ptr<Object> camera WARN;
|
|
std::shared_ptr<World> world WARN;
|
|
std::shared_ptr<Base> basact WARN;
|
|
|
|
ListBase base;
|
|
|
|
Scene()
|
|
: ElemBase()
|
|
, camera()
|
|
, world()
|
|
, basact() {
|
|
// empty
|
|
}
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Image : ElemBase {
|
|
ID id FAIL;
|
|
|
|
char name[240] WARN;
|
|
|
|
//struct anim *anim;
|
|
|
|
short ok, flag;
|
|
short source, type, pad, pad1;
|
|
int lastframe;
|
|
|
|
short tpageflag, totbind;
|
|
short xrep, yrep;
|
|
short twsta, twend;
|
|
//unsigned int bindcode;
|
|
//unsigned int *repbind;
|
|
|
|
std::shared_ptr<PackedFile> packedfile;
|
|
//struct PreviewImage * preview;
|
|
|
|
float lastupdate;
|
|
int lastused;
|
|
short animspeed;
|
|
|
|
short gen_x, gen_y, gen_type;
|
|
|
|
Image()
|
|
: ElemBase() {
|
|
// empty
|
|
}
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct Tex : ElemBase {
|
|
|
|
// actually, the only texture type we support is Type_IMAGE
|
|
enum Type {
|
|
Type_CLOUDS = 1
|
|
,Type_WOOD = 2
|
|
,Type_MARBLE = 3
|
|
,Type_MAGIC = 4
|
|
,Type_BLEND = 5
|
|
,Type_STUCCI = 6
|
|
,Type_NOISE = 7
|
|
,Type_IMAGE = 8
|
|
,Type_PLUGIN = 9
|
|
,Type_ENVMAP = 10
|
|
,Type_MUSGRAVE = 11
|
|
,Type_VORONOI = 12
|
|
,Type_DISTNOISE = 13
|
|
,Type_POINTDENSITY = 14
|
|
,Type_VOXELDATA = 15
|
|
};
|
|
|
|
enum ImageFlags {
|
|
ImageFlags_INTERPOL = 1
|
|
,ImageFlags_USEALPHA = 2
|
|
,ImageFlags_MIPMAP = 4
|
|
,ImageFlags_IMAROT = 16
|
|
,ImageFlags_CALCALPHA = 32
|
|
,ImageFlags_NORMALMAP = 2048
|
|
,ImageFlags_GAUSS_MIP = 4096
|
|
,ImageFlags_FILTER_MIN = 8192
|
|
,ImageFlags_DERIVATIVEMAP = 16384
|
|
};
|
|
|
|
ID id FAIL;
|
|
// AnimData *adt;
|
|
|
|
//float noisesize, turbul;
|
|
//float bright, contrast, rfac, gfac, bfac;
|
|
//float filtersize;
|
|
|
|
//float mg_H, mg_lacunarity, mg_octaves, mg_offset, mg_gain;
|
|
//float dist_amount, ns_outscale;
|
|
|
|
//float vn_w1;
|
|
//float vn_w2;
|
|
//float vn_w3;
|
|
//float vn_w4;
|
|
//float vn_mexp;
|
|
//short vn_distm, vn_coltype;
|
|
|
|
//short noisedepth, noisetype;
|
|
//short noisebasis, noisebasis2;
|
|
|
|
//short flag;
|
|
ImageFlags imaflag;
|
|
Type type FAIL;
|
|
//short stype;
|
|
|
|
//float cropxmin, cropymin, cropxmax, cropymax;
|
|
//int texfilter;
|
|
//int afmax;
|
|
//short xrepeat, yrepeat;
|
|
//short extend;
|
|
|
|
//short fie_ima;
|
|
//int len;
|
|
//int frames, offset, sfra;
|
|
|
|
//float checkerdist, nabla;
|
|
//float norfac;
|
|
|
|
//ImageUser iuser;
|
|
|
|
//bNodeTree *nodetree;
|
|
//Ipo *ipo;
|
|
std::shared_ptr<Image> ima WARN;
|
|
//PluginTex *plugin;
|
|
//ColorBand *coba;
|
|
//EnvMap *env;
|
|
//PreviewImage * preview;
|
|
//PointDensity *pd;
|
|
//VoxelData *vd;
|
|
|
|
//char use_nodes;
|
|
|
|
Tex()
|
|
: ElemBase()
|
|
, imaflag( ImageFlags_INTERPOL )
|
|
, type( Type_CLOUDS )
|
|
, ima() {
|
|
// empty
|
|
}
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
struct MTex : ElemBase {
|
|
|
|
enum Projection {
|
|
Proj_N = 0
|
|
,Proj_X = 1
|
|
,Proj_Y = 2
|
|
,Proj_Z = 3
|
|
};
|
|
|
|
enum Flag {
|
|
Flag_RGBTOINT = 0x1
|
|
,Flag_STENCIL = 0x2
|
|
,Flag_NEGATIVE = 0x4
|
|
,Flag_ALPHAMIX = 0x8
|
|
,Flag_VIEWSPACE = 0x10
|
|
};
|
|
|
|
enum BlendType {
|
|
BlendType_BLEND = 0
|
|
,BlendType_MUL = 1
|
|
,BlendType_ADD = 2
|
|
,BlendType_SUB = 3
|
|
,BlendType_DIV = 4
|
|
,BlendType_DARK = 5
|
|
,BlendType_DIFF = 6
|
|
,BlendType_LIGHT = 7
|
|
,BlendType_SCREEN = 8
|
|
,BlendType_OVERLAY = 9
|
|
,BlendType_BLEND_HUE = 10
|
|
,BlendType_BLEND_SAT = 11
|
|
,BlendType_BLEND_VAL = 12
|
|
,BlendType_BLEND_COLOR = 13
|
|
};
|
|
|
|
enum MapType {
|
|
MapType_COL = 1
|
|
,MapType_NORM = 2
|
|
,MapType_COLSPEC = 4
|
|
,MapType_COLMIR = 8
|
|
,MapType_REF = 16
|
|
,MapType_SPEC = 32
|
|
,MapType_EMIT = 64
|
|
,MapType_ALPHA = 128
|
|
,MapType_HAR = 256
|
|
,MapType_RAYMIRR = 512
|
|
,MapType_TRANSLU = 1024
|
|
,MapType_AMB = 2048
|
|
,MapType_DISPLACE = 4096
|
|
,MapType_WARP = 8192
|
|
};
|
|
|
|
// short texco, maptoneg;
|
|
MapType mapto;
|
|
|
|
BlendType blendtype;
|
|
std::shared_ptr<Object> object;
|
|
std::shared_ptr<Tex> tex;
|
|
char uvname[32];
|
|
|
|
Projection projx,projy,projz;
|
|
char mapping;
|
|
float ofs[3], size[3], rot;
|
|
|
|
int texflag;
|
|
short colormodel, pmapto, pmaptoneg;
|
|
//short normapspace, which_output;
|
|
//char brush_map_mode;
|
|
float r,g,b,k WARN;
|
|
//float def_var, rt;
|
|
|
|
//float colfac, varfac;
|
|
|
|
float norfac;
|
|
//float dispfac, warpfac;
|
|
float colspecfac, mirrfac, alphafac;
|
|
float difffac, specfac, emitfac, hardfac;
|
|
//float raymirrfac, translfac, ambfac;
|
|
//float colemitfac, colreflfac, coltransfac;
|
|
//float densfac, scatterfac, reflfac;
|
|
|
|
//float timefac, lengthfac, clumpfac;
|
|
//float kinkfac, roughfac, padensfac;
|
|
//float lifefac, sizefac, ivelfac, pvelfac;
|
|
//float shadowfac;
|
|
//float zenupfac, zendownfac, blendfac;
|
|
|
|
MTex()
|
|
: ElemBase() {
|
|
// empty
|
|
}
|
|
};
|
|
|
|
}
|
|
}
|
|
#endif
|