From 058f98a63658dc1a2579826ba167fd61bed1e21f Mon Sep 17 00:00:00 2001 From: sanine Date: Fri, 4 Mar 2022 10:47:15 -0600 Subject: add assimp submodule --- .../code/AssetLib/Blender/BlenderScene.h | 983 +++++++++++++++++++++ 1 file changed, 983 insertions(+) create mode 100644 src/mesh/assimp-master/code/AssetLib/Blender/BlenderScene.h (limited to 'src/mesh/assimp-master/code/AssetLib/Blender/BlenderScene.h') diff --git a/src/mesh/assimp-master/code/AssetLib/Blender/BlenderScene.h b/src/mesh/assimp-master/code/AssetLib/Blender/BlenderScene.h new file mode 100644 index 0000000..c153d3c --- /dev/null +++ b/src/mesh/assimp-master/code/AssetLib/Blender/BlenderScene.h @@ -0,0 +1,983 @@ +/* +Open Asset Import Library (assimp) +---------------------------------------------------------------------- + +Copyright (c) 2006-2022, 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; +struct Collection; + +#include + +#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 first; + std::shared_ptr last; +}; + +// ------------------------------------------------------------------------------- +struct PackedFile : ElemBase { + int size WARN; + int seek WARN; + std::shared_ptr data WARN; +}; + +// ------------------------------------------------------------------------------- +struct GroupObject : ElemBase { + std::shared_ptr prev, next FAIL; + std::shared_ptr ob; +}; + +// ------------------------------------------------------------------------------- +struct Group : ElemBase { + ID id FAIL; + int layer; + + std::shared_ptr gobject; +}; + +// ------------------------------------------------------------------------------- +struct CollectionObject : ElemBase { + //CollectionObject* prev; + std::shared_ptr next; + Object *ob; +}; + +// ------------------------------------------------------------------------------- +struct CollectionChild : ElemBase { + std::shared_ptr next, prev; + std::shared_ptr collection; +}; + +// ------------------------------------------------------------------------------- +struct Collection : ElemBase { + ID id FAIL; + ListBase gobject; // CollectionObject + ListBase children; // CollectionChild +}; + +// ------------------------------------------------------------------------------- +struct World : ElemBase { + ID id FAIL; +}; + +// ------------------------------------------------------------------------------- +struct MVert : ElemBase { + float co[3] FAIL; + float no[3] FAIL; // read as short and divided through / 32767.f + char flag; + int mat_nr WARN; + int bweight; + + MVert() : + ElemBase(), flag(0), mat_nr(0), bweight(0) {} +}; + +// ------------------------------------------------------------------------------- +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 { + MTFace() : + flag(0), + mode(0), + tile(0), + unwrap(0) { + } + + float uv[4][2] FAIL; + char flag; + short mode; + short tile; + short unwrap; + + // std::shared_ptr tpage; +}; + +// ------------------------------------------------------------------------------- +struct MDeformWeight : ElemBase { + int def_nr FAIL; + float weight FAIL; +}; + +// ------------------------------------------------------------------------------- +struct MDeformVert : ElemBase { + vector 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; + + short diff_shader WARN; + short spec_shader WARN; + + std::shared_ptr mtex[18]; +}; + +/* +CustomDataLayer 104 + + int type 0 4 + int offset 4 4 + int flag 8 4 + int active 12 4 + int active_rnd 16 4 + int active_clone 20 4 + int active_mask 24 4 + int uid 28 4 + char name 32 64 + void *data 96 8 +*/ +struct CustomDataLayer : ElemBase { + int type; + int offset; + int flag; + int active; + int active_rnd; + int active_clone; + int active_mask; + int uid; + char name[64]; + std::shared_ptr data; // must be converted to real type according type member + + CustomDataLayer() : + ElemBase(), + type(0), + offset(0), + flag(0), + active(0), + active_rnd(0), + active_clone(0), + active_mask(0), + uid(0), + data(nullptr) { + memset(name, 0, sizeof name); + } +}; + +/* +CustomData 208 + + CustomDataLayer *layers 0 8 + int typemap 8 168 + int pad_i1 176 4 + int totlayer 180 4 + int maxlayer 184 4 + int totsize 188 4 + BLI_mempool *pool 192 8 + CustomDataExternal *external 200 8 +*/ +struct CustomData : ElemBase { + vector> layers; + int typemap[42]; // CD_NUMTYPES + int totlayer; + int maxlayer; + int totsize; + /* + std::shared_ptr pool; + std::shared_ptr external; + */ +}; + +// ------------------------------------------------------------------------------- +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 FAIL; + vector mtface; + vector tface; + vector mvert FAIL; + vector medge WARN; + vector mloop; + vector mloopuv; + vector mloopcol; + vector mpoly; + vector mtpoly; + vector dvert; + vector mcol; + + vector> mat FAIL; + + struct CustomData vdata; + struct CustomData edata; + struct CustomData fdata; + struct CustomData pdata; + struct CustomData ldata; +}; + +// ------------------------------------------------------------------------------- +struct Library : ElemBase { + ID id FAIL; + + char name[240] WARN; + char filename[240] FAIL; + std::shared_ptr 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 constant_coefficient; + float linear_coefficient; + float quadratic_coefficient; + + 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 next WARN; + std::shared_ptr 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 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 track WARN; + + std::shared_ptr proxy, proxy_from, proxy_group WARN; + std::shared_ptr dup_group WARN; + std::shared_ptr 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 next WARN; + std::shared_ptr object WARN; + + Base() : + ElemBase(), prev(nullptr), next(), object() { + // empty + // empty + } +}; + +// ------------------------------------------------------------------------------- +struct Scene : ElemBase { + ID id FAIL; + + std::shared_ptr camera WARN; + std::shared_ptr world WARN; + std::shared_ptr basact WARN; + std::shared_ptr master_collection WARN; + + ListBase base; + + Scene() : + ElemBase(), camera(), world(), basact(), master_collection() { + // 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; + //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 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; + std::shared_ptr 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 + } +}; + +} // namespace Blender +} // namespace Assimp +#endif -- cgit v1.2.1