1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/.hgignore	Thu Nov 14 05:27:09 2013 +0200
     1.3 @@ -0,0 +1,7 @@
     1.4 +\.o$
     1.5 +\.d$
     1.6 +\.swp$
     1.7 +\.a$
     1.8 +\.so\.
     1.9 +\.so$
    1.10 +\.dylib$

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/Makefile	Thu Nov 14 05:27:09 2013 +0200
     2.3 @@ -0,0 +1,80 @@
     2.4 +PREFIX = /usr/local
     2.5 +
     2.6 +csrc = $(wildcard src/*.c)
     2.7 +ccsrc = $(wildcard src/*.cc)
     2.8 +obj = $(csrc:.c=.o) $(ccsrc:.cc=.o)
     2.9 +dep = $(obj:.o=.d)
    2.10 +name = goat3dgfx
    2.11 +lib_a = lib$(name).a
    2.12 +
    2.13 +so_major = 0
    2.14 +so_minor = 1
    2.15 +
    2.16 +ifeq ($(shell uname -r), Darwin)
    2.17 +	libgl = -framework OpenGL -framework GLUT -lGLEW
    2.18 +
    2.19 +	lib_so = lib$(name).dylib
    2.20 +	shared = -dynamiclib
    2.21 +else
    2.22 +	libgl = -lGL -lGLU -lglut -lGLEW
    2.23 +
    2.24 +	lib_so = lib$(name).so.$(so_major).$(so_minor)
    2.25 +	soname = lib$(name).so.$(so_major)
    2.26 +	devlink = lib$(name).so
    2.27 +	shared = -shared -Wl,-soname=$(soname)
    2.28 +	pic = -fPIC
    2.29 +endif
    2.30 +
    2.31 +
    2.32 +CFLAGS = -pedantic $(warn) $(dbg) $(pic) $(opt) $(inc) $(libs_cflags)
    2.33 +CXXFLAGS =  $(CFLAGS)
    2.34 +LDFLAGS = $(libgl) $(libs_ldflags)
    2.35 +
    2.36 +.PHONY: all
    2.37 +all: $(lib_so) $(lib_a)
    2.38 +
    2.39 +$(lib_a): $(obj)
    2.40 +	$(AR) rcs $@ $(obj)
    2.41 +
    2.42 +$(lib_so): $(obj)
    2.43 +	$(CXX) $(shared) -o $@ $(obj) $(LDFLAGS)
    2.44 +
    2.45 +-include $(dep)
    2.46 +
    2.47 +%.d: %.c
    2.48 +	@$(CPP) $(CFLAGS) $< -MM -MT $(@:.d=.o) >$@
    2.49 +
    2.50 +%.d: %.cc
    2.51 +	@$(CPP) $(CXXFLAGS) $< -MM -MT $(@:.d=.o) >$@
    2.52 +
    2.53 +.PHONY: clean
    2.54 +clean:
    2.55 +	rm -f $(obj) $(lib_a) $(lib_so)
    2.56 +
    2.57 +.PHONY: cleandep
    2.58 +cleandep:
    2.59 +	rm -f $(dep)
    2.60 +
    2.61 +.PHONY: install
    2.62 +install: $(lib_so) $(lib_a)
    2.63 +	mkdir -p $(DESTDIR)$(PREFIX)/lib $(DESTDIR)$(PREFIX)/include/goat3dgfx
    2.64 +	cp src/*.h src/*.inl $(DESTDIR)$(PREFIX)/include/goat3dgfx/
    2.65 +	cp $(lib_a) $(DESTDIR)$(PREFIX)/lib/$(lib_a)
    2.66 +	cp $(lib_so) $(DESTDIR)$(PREFIX)/lib/$(lib_so)
    2.67 +	[ -n "$(devlink)" ] && \
    2.68 +		cd $(DESTDIR)$(PREFIX)/lib && \
    2.69 +		rm -f $(soname) $(devlink) && \
    2.70 +		ln -s $(lib_so) $(soname) && \
    2.71 +		ln -s $(soname) $(devlink) || \
    2.72 +		true
    2.73 +
    2.74 +.PHONY: uninstall
    2.75 +uninstall:
    2.76 +	rm -f $(DESTDIR)$(PREFIX)/include/goat3dgfx/*
    2.77 +	rmdir $(DESTDIR)$(PREFIX)/include/goat3dgfx
    2.78 +	rm -f $(DESTDIR)$(PREFIX)/lib/$(lib_so)
    2.79 +	rm -f $(DESTDIR)$(PREFIX)/lib/$(lib_a)
    2.80 +	[ -n "$(devlink)" ] && \
    2.81 +		rm -f $(DESTDIR)$(PREFIX)/lib/$(soname) && \
    2.82 +		rm -f $(DESTDIR)$(PREFIX)/lib/$(devlink) || \
    2.83 +		true

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/src/3dschunks.h	Thu Nov 14 05:27:09 2013 +0200
     3.3 @@ -0,0 +1,160 @@
     3.4 +#ifndef _3DSCHUNKS_H_
     3.5 +#define _3DSCHUNKS_H_
     3.6 +
     3.7 +enum ChunkID {
     3.8 +	Chunk_Color_Float3					= 0x0010,	// o Floating point color
     3.9 +	Chunk_Color_Byte3					= 0x0011,	// o 24bit color
    3.10 +	Chunk_Color_GammaByte3				= 0x0012,	// o 24bit gamma corrected
    3.11 +	Chunk_Color_GammaFloat3				= 0x0013,	// o Floating point gamma corrected
    3.12 +	Chunk_PercentInt					= 0x0030,	// o Percent Chunk int 0 - 100
    3.13 +	Chunk_PercentFloat					= 0x0031,	// o Percent Chunk float 0 - 1
    3.14 +
    3.15 +	Chunk_3DSMain						= 0x4D4D,	// + Root Chunk
    3.16 +	Chunk_Main_3DSVersion				= 0x0002,	//   - 3DS Version
    3.17 +	Chunk_Main_3DEditor					= 0x3D3D,	//   + 3D Editor Chunk
    3.18 +	Chunk_Edit_Unit						= 0x0100,	//     - Unit
    3.19 +	Chunk_Edit_BGBitmap					= 0x1100,	//     - Background Bitmap
    3.20 +	Chunk_Edit_UseBGBitmap				= 0x1101,	//     - Use Background Bitmap
    3.21 +	Chunk_Edit_BGColor					= 0x1200,	//     - Background Color
    3.22 +	Chunk_Edit_UseBGColor				= 0x1201,	//     - Use Background Color
    3.23 +	Chunk_Edit_GradColor				= 0x1300,	//     - Background Gradient
    3.24 +	Chunk_Edit_UseGradColor				= 0x1301,	//     - Use Gradient Color
    3.25 +	Chunk_Edit_ShadowMapBias			= 0x1400,	//     - Shadow map bias
    3.26 +	Chunk_Edit_ShadowMapSize			= 0x1420,	//     - Shadow map size
    3.27 +	Chunk_Edit_ShadowMapSampleRange		= 0x1450,	//     - Shadow map sample range
    3.28 +	Chunk_Edit_RaytraceBias				= 0x1460,	//     - Raytrace bias
    3.29 +	Chunk_Edit_UseRaytrace				= 0x1470,	//     - Use Raytrace
    3.30 +	Chunk_Edit_AmbientColor				= 0x2100,	//     - Ambient Color
    3.31 +	Chunk_Edit_Fog						= 0x2200,	//     + Fog
    3.32 +	Chunk_Fog_FogColor					= 0x2210,	//	     - Fog Color
    3.33 +	Chunk_Edit_UseFog					= 0x2201,	//     - Use Fog
    3.34 +	Chunk_Edit_DistanceQue				= 0x2300,	//     + Distance que
    3.35 +	Chunk_Dist_DimBackground			= 0x2310,	//       - Dim Background
    3.36 +	Chunk_Edit_UseDistanceQue			= 0x2301,	//     - Use distance que
    3.37 +	Chunk_Edit_LayeredFogOptions		= 0x2302,	//     - Layered fog options
    3.38 +	Chunk_Edit_UseLayeredFog			= 0x2303,	//     - Use Layered Fog
    3.39 +	Chunk_Edit_MeshVersion				= 0x3D3E,	//     - Mesh Version
    3.40 +
    3.41 +	Chunk_Edit_Object					= 0x4000,	//     + Object
    3.42 +	Chunk_Obj_Hidden					= 0x4010,	//       - Hidden
    3.43 +	Chunk_Obj_DontCastShadows			= 0x4012,	//       - Object doesn't cast shadows
    3.44 +	Chunk_Obj_MatteObject				= 0x4013,	//       - Matte
    3.45 +	Chunk_Obj_ExternalProcessOn			= 0x4015,	//       - External Process on (?)
    3.46 +	Chunk_Obj_DontReceiveShadows		= 0x4017,	//       - doesn't reseive shadows
    3.47 +	Chunk_Obj_TriMesh					= 0x4100,	//       + TriMesh
    3.48 +	Chunk_TriMesh_VertexList			= 0x4110,	//         - Vertex List
    3.49 +	Chunk_TriMesh_FaceDesc				= 0x4120,	//         + Faces description
    3.50 +	Chunk_Face_Material					= 0x4130,	//           - Face Materials*
    3.51 +	Chunk_TriMesh_TexCoords				= 0x4140,	//         - Texture Coordinates
    3.52 +	Chunk_TriMesh_SmoothingGroup		= 0x4150,	//         - Smoothing group
    3.53 +	Chunk_TriMesh_WorldTransform		= 0x4160,	//         - Position and Orientation
    3.54 +	Chunk_TriMesh_Color					= 0x4165,   //         - Object color
    3.55 +	Chunk_TriMesh_ExternalProcessName	= 0x4181,	//         - External Process name (?)
    3.56 +	Chunk_TriMesh_ExternalProcessParams	= 0x4182,	//         - External Process parameters (?)
    3.57 +
    3.58 +	Chunk_Obj_Light						= 0x4600,	//       + Light
    3.59 +	Chunk_Light_SpotLight				= 0x4610,	//         + SpotLight
    3.60 +	Chunk_Spot_Raytrace					= 0x4627,	//           - Raytrace
    3.61 +	Chunk_Spot_CastShadows				= 0x4630,	//           - Light casts shadows
    3.62 +	Chunk_Spot_ShadowMap				= 0x4641,	//           - Shadow Map
    3.63 +	Chunk_Spot_ShowCone					= 0x4650,	//           - Show Cone
    3.64 +	Chunk_Spot_Rectangular				= 0x4651,	//           - Rectangular shaped spotlight
    3.65 +	Chunk_Spot_OverShoot				= 0x4652,	//           - Overshoot
    3.66 +	Chunk_Spot_ProjMap					= 0x4653,	//           - Projector Map
    3.67 +	Chunk_Spot_Roll						= 0x4656,	//           - Roll around dir
    3.68 +	Chunk_Spot_RaytraceBias				= 0x4658,	//           - Raytrace Bias
    3.69 +	Chunk_Light_Off						= 0x4620,	//         - Light is disabled
    3.70 +	Chunk_Light_Attenuation				= 0x4625,	//         - Attenuation enabled
    3.71 +	Chunk_Light_AttenuationStart		= 0x4659,	//         - Attenuation Start Range
    3.72 +	Chunk_Light_AttenuationEnd			= 0x465A,	//         - Attenuation End Range
    3.73 +	Chunk_Light_Intensity				= 0x465B,	//         - Light Intensity
    3.74 +
    3.75 +	Chunk_Obj_Camera					= 0x4700,	//       - Camera
    3.76 +	Chunk_Edit_ViewSettings				= 0x7001,	//     - View Settings
    3.77 +	Chunk_Edit_ViewDesc2				= 0x7011,	//     - View Description 2
    3.78 +	Chunk_Edit_ViewDesc1				= 0x7012,	//     - View Description 1
    3.79 +	Chunk_Edit_MeshWindows				= 0x7020,	//     - Mesh Windows (?)
    3.80 +
    3.81 +	Chunk_Edit_Material					= 0xAFFF,	//     + Material Block
    3.82 +	Chunk_Mat_Name						= 0xA000,	//       - Material Name
    3.83 +	Chunk_Mat_AmbientColor				= 0xA010,	//       - Ambient Color
    3.84 +	Chunk_Mat_DiffuseColor				= 0xA020,	//       - Diffuse Color
    3.85 +	Chunk_Mat_SpecularColor				= 0xA030,	//       - Specular Color
    3.86 +	Chunk_Mat_Specular					= 0xA040,	//       - Shininness (Specular Power)
    3.87 +	Chunk_Mat_SpecularIntensity			= 0xA041,	//       - Shininness Strength (specular intensity)
    3.88 +	Chunk_Mat_Transparency				= 0xA050,	//       - Transparency (alpha)
    3.89 +	Chunk_Mat_TransparencyFalloff		= 0xA052,	//       - Transparency Falloff
    3.90 +	Chunk_Mat_ReflectionBlur			= 0xA053,	//       - Reflection Blur
    3.91 +	Chunk_Mat_TwoSided					= 0xA081,	//       - Two Sided
    3.92 +	Chunk_Mat_AddTransparency			= 0xA083,	//       - ?
    3.93 +	Chunk_Mat_SelfIllumination			= 0xA084,	//       - Self Illumination (emissive)
    3.94 +	Chunk_Mat_Wireframe					= 0xA085,	//       - Render in wireframe
    3.95 +	Chunk_Mat_WireframeThickness		= 0xA087,	//       - Wire thickness
    3.96 +	Chunk_Mat_FaceMapping				= 0xA088,	//       - Apply maps to faces seperatly (ignore uv)
    3.97 +	Chunk_Mat_InTranc					= 0xA08A,	// ?
    3.98 +	Chunk_Mat_Soften					= 0xA08C,	//       - Soft Shading
    3.99 +	Chunk_Mat_WireUnits					= 0xA08E,	//       - Wire units (?)
   3.100 +	Chunk_Mat_RenderType				= 0xA100,	//       - Render Type
   3.101 +	Chunk_Mat_BumpMapPercent			= 0xA252,	//       - Bump map intensity
   3.102 +	Chunk_Mat_TextureMap				= 0xA200,	//       + Texture Map
   3.103 +	Chunk_Mat_TextureMap2				= 0xA33A,	//       + Texture Map 2
   3.104 +	Chunk_Mat_OpacityMap				= 0xA210,	//       + Opacity Map
   3.105 +	Chunk_Mat_BumpMap					= 0xA230,	//       + Bump Map
   3.106 +	Chunk_Mat_SpecularMap				= 0xA33C,	//       + Specular Intensity map
   3.107 +	Chunk_Mat_SpecularColorMap			= 0xA204,	//       + Specular color (texture) map
   3.108 +	Chunk_Mat_SelfIlluminationMap		= 0xA33D,	//       + Self Illumination Map
   3.109 +	Chunk_Mat_ReflectionMap				= 0xA220,	//       + Reflection Map
   3.110 +	Chunk_Mat_TextureMask				= 0xA33E,	//       - Texture Mask
   3.111 +	Chunk_Mat_Texture2Mask				= 0xA340,	//       - Texture 2 Mask
   3.112 +	Chunk_Mat_OpacityMask				= 0xA342,	//       - Opacity Mask
   3.113 +	Chunk_Mat_BumpMask					= 0xA344,	//       - Bump Mask
   3.114 +	Chunk_Mat_SpecularMask				= 0xA346,	//       - Specular Mask
   3.115 +	Chunk_Mat_SpecularColorMask			= 0xA348,	//       - Specular color mask
   3.116 +	Chunk_Mat_SelfIlluminationMask		= 0xA34A,	//       - Self Illumination mask
   3.117 +	Chunk_Mat_ReflectionMask			= 0xA34C,	//       - Reflection mask
   3.118 +
   3.119 +	// map subchunks								// -----------------------
   3.120 +	Chunk_Map_FileName					= 0xA300,	//         - Filename
   3.121 +	Chunk_Map_Params					= 0xA351,	//         - Parameters
   3.122 +	Chunk_Map_BlurPercent				= 0xA353,	//         - Blur ammount
   3.123 +	Chunk_Map_VScale					= 0xA354,	//         - Texture V Scale
   3.124 +	Chunk_Map_UScale					= 0xA356,	//         - Texture U Scale
   3.125 +	Chunk_Map_UOffset					= 0xA358,	//         - Texture U Offset
   3.126 +	Chunk_MAP_VOffset					= 0xA35A,	//         - Texture V Offset
   3.127 +	Chunk_Map_RotationAngle				= 0xA35C,	//         - Texture Rotation Angle
   3.128 +	Chunk_Map_RGBLumAlphaTint1			= 0xA360,	//         - RGB Luminance Alpha Tint 1
   3.129 +	Chunk_Map_RGBLumAlphaTint2			= 0xA362,	//         - RGB Luminance Alpha Tint 2
   3.130 +	Chunk_Map_RGBTintR					= 0xA364,	//         - RGB Tint R
   3.131 +	Chunk_Map_RGBTintG					= 0xA366,	//         - RGB Tint G
   3.132 +	Chunk_Map_RGBTintB					= 0xA368,	//         - RGB Tint B
   3.133 +	// map subchunks end							// -----------------------
   3.134 +
   3.135 +	Chunk_Main_Keyframer				= 0xB000,	//     + Keyframer Chunk
   3.136 +	Chunk_Key_AmbientInfo				= 0xB001,	//       - Ambient animation info
   3.137 +	Chunk_Key_MeshInfo					= 0xB002,	//       - Mesh animation info
   3.138 +	Chunk_Key_CameraInfo				= 0xB003,	//       - Camera animation info
   3.139 +	Chunk_Key_CameraTargetInfo			= 0xB004,	//       - Camera Target animation info
   3.140 +	Chunk_Key_OmniLightInfo				= 0xB005,	//       - Omni Light animation info
   3.141 +	Chunk_Key_SpotLightTargetInfo		= 0xB006,	//       - Spotlight target animation info
   3.142 +	Chunk_Key_SpotLightInfo				= 0xB007,	//       - Spotlight animation info
   3.143 +	Chunk_Key_Frames					= 0xB008,	//       - Animation Frames
   3.144 +
   3.145 +	// animation information subchunks				// -----------------------
   3.146 +	Chunk_Info_Object					= 0xB010,	//         - Object information
   3.147 +	Chunk_Info_ObjectPivot				= 0xB013,	//         - Object Pivot
   3.148 +	Chunk_Info_ObjectMorphAngle			= 0xB015,	//         - Object Morph Angle
   3.149 +	Chunk_Info_PositionTrack			= 0xB020,	//         - Position Track
   3.150 +	Chunk_Info_RotationTrack			= 0xB021,	//         - Rotation Track
   3.151 +	Chunk_Info_ScaleTrack				= 0xB022,	//         - Scaling Track
   3.152 +	Chunk_Info_FOVTrack					= 0xB023,	//         - FOV Track
   3.153 +	Chunk_Info_RollTrack				= 0xB024,	//         - Roll Track
   3.154 +	Chunk_Info_ColorTrack				= 0xB025,	//         - Color Track
   3.155 +	Chunk_Info_MorphTrack				= 0xB026,	//         - Morph Track
   3.156 +	Chunk_Info_HotSpotTrack				= 0xB027,	//         - HotSpot Track
   3.157 +	Chunk_Info_FalloffTrack				= 0xB028,	//         - Falloff Track
   3.158 +	Chunk_Info_HideTrack				= 0xB029,	//         - Hide Track
   3.159 +	Chunk_Info_HierarchyPosition		= 0xB030	//         - Hierarchy Position
   3.160 +};
   3.161 +
   3.162 +#endif	// _3DSCHUNKS_H_
   3.163 +

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/src/assload.cc	Thu Nov 14 05:27:09 2013 +0200
     4.3 @@ -0,0 +1,437 @@
     4.4 +#include <stdio.h>
     4.5 +#include "assload.h"
     4.6 +#include "logger.h"
     4.7 +#include "datapath.h"
     4.8 +
     4.9 +#ifdef USE_ASSIMP
    4.10 +
    4.11 +#include <vector>
    4.12 +#include <map>
    4.13 +#include "assimp/cimport.h"
    4.14 +#include "assimp/scene.h"
    4.15 +#include "assimp/postprocess.h"
    4.16 +#include "texman.h"
    4.17 +#include "material.h"
    4.18 +
    4.19 +using namespace std;
    4.20 +
    4.21 +static bool load_material(Material *mat, const aiMaterial *aimat);
    4.22 +static Object *load_node(const aiScene *aiscn, const aiNode *ainode);
    4.23 +static Mesh *load_mesh(const aiScene *aiscn, const aiMesh *aimesh);
    4.24 +static Curve *load_curve(const aiScene *aiscn, const aiMesh *aimesh);
    4.25 +static bool load_bones(Mesh *mesh, const aiMesh *aimesh);
    4.26 +
    4.27 +static Vector3 assimp_vector(const aiVector3D &v);
    4.28 +static Quaternion assimp_quat(const aiQuaternion &q);
    4.29 +static Matrix4x4 assimp_matrix(const aiMatrix4x4 &aim);
    4.30 +static long assimp_time(const aiAnimation *anim, double aitime);
    4.31 +static void print_hierarchy(const aiNode *node);
    4.32 +
    4.33 +static map<string, Object*> obj_by_name;
    4.34 +static map<aiMesh*, Mesh*> mesh_by_aimesh;
    4.35 +
    4.36 +bool load_ass(Scene *scn, const char *fname)
    4.37 +{
    4.38 +	static bool init_done;
    4.39 +
    4.40 +	if(!init_done) {
    4.41 +		static aiLogStream log_stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT, 0);
    4.42 +		aiAttachLogStream(&log_stream);
    4.43 +		//aiEnableVerboseLogging(1);
    4.44 +		init_done = true;
    4.45 +	}
    4.46 +
    4.47 +	unsigned int proc_flags = aiProcess_JoinIdenticalVertices |
    4.48 +		aiProcess_CalcTangentSpace |
    4.49 +		aiProcess_Triangulate |
    4.50 +		aiProcess_SortByPType |
    4.51 +		aiProcess_FlipUVs;
    4.52 +
    4.53 +	const aiScene *aiscn = aiImportFile(datafile_path(fname).c_str(), proc_flags);
    4.54 +	if(!aiscn) {
    4.55 +		error_log("failed to load file: %s\n", fname);
    4.56 +		return false;
    4.57 +	}
    4.58 +
    4.59 +	info_log("NODE HIERARCHY:\n");
    4.60 +	print_hierarchy(aiscn->mRootNode);
    4.61 +	info_log("-------------------\n");
    4.62 +
    4.63 +	Vector3 root_pos, root_scaling(1.0, 1.0, 1.0);
    4.64 +	Quaternion root_rot;
    4.65 +
    4.66 +	if(aiscn->mRootNode) {
    4.67 +		Matrix4x4 root_matrix = assimp_matrix(aiscn->mRootNode->mTransformation);
    4.68 +		root_pos = root_matrix.get_translation();
    4.69 +		root_rot = root_matrix.get_rotation_quat();
    4.70 +		root_scaling = root_matrix.get_scaling();
    4.71 +	}
    4.72 +
    4.73 +	// load all meshes
    4.74 +	for(unsigned int i=0; i<aiscn->mNumMeshes; i++) {
    4.75 +		aiMesh *aimesh = aiscn->mMeshes[i];
    4.76 +		Mesh *mesh;
    4.77 +		Curve *curve;
    4.78 +
    4.79 +		switch(aimesh->mPrimitiveTypes) {
    4.80 +		case aiPrimitiveType_TRIANGLE:
    4.81 +			if((mesh = load_mesh(aiscn, aimesh))) {
    4.82 +				mesh_by_aimesh[aimesh] = mesh;
    4.83 +				scn->meshes.push_back(mesh);
    4.84 +			}
    4.85 +			break;
    4.86 +
    4.87 +		case aiPrimitiveType_LINE:
    4.88 +			if((curve = load_curve(aiscn, aimesh))) {
    4.89 +				scn->curves.push_back(curve);
    4.90 +			}
    4.91 +			break;
    4.92 +
    4.93 +		default:
    4.94 +			error_log("unsupported primitive type: %u\n", aimesh->mPrimitiveTypes);
    4.95 +			break;
    4.96 +		}
    4.97 +	}
    4.98 +
    4.99 +	// load all the nodes recursively
   4.100 +	for(unsigned int i=0; i<aiscn->mRootNode->mNumChildren; i++) {
   4.101 +		Object *obj = load_node(aiscn, aiscn->mRootNode->mChildren[i]);
   4.102 +		if(obj) {
   4.103 +			Object *dummy = new Object;
   4.104 +			dummy->set_name((string("dummyroot_") + string(obj->get_name())).c_str());
   4.105 +			dummy->set_position(root_pos);
   4.106 +			dummy->set_rotation(root_rot);
   4.107 +			dummy->set_scaling(root_scaling);
   4.108 +			dummy->add_child(obj);
   4.109 +
   4.110 +			obj = dummy;
   4.111 +			scn->objects.push_back(obj);
   4.112 +		}
   4.113 +	}
   4.114 +
   4.115 +	// load and attach the bones to the meshes
   4.116 +	for(unsigned int i=0; i<aiscn->mNumMeshes; i++) {
   4.117 +		aiMesh *aimesh = aiscn->mMeshes[i];
   4.118 +
   4.119 +		Mesh *mesh = mesh_by_aimesh[aimesh];
   4.120 +		load_bones(mesh, aimesh);
   4.121 +	}
   4.122 +
   4.123 +	obj_by_name.clear();
   4.124 +	mesh_by_aimesh.clear();
   4.125 +
   4.126 +	aiReleaseImport(aiscn);
   4.127 +	return true;
   4.128 +}
   4.129 +
   4.130 +static bool load_material(Material *mat, const aiMaterial *aimat)
   4.131 +{
   4.132 +	aiColor4D aicol;
   4.133 +	float shin, shin_str;
   4.134 +
   4.135 +	if(aiGetMaterialColor(aimat, AI_MATKEY_COLOR_DIFFUSE, &aicol) == 0) {
   4.136 +		mat->diffuse = Vector3(aicol[0], aicol[1], aicol[2]);
   4.137 +	}
   4.138 +	if(aiGetMaterialColor(aimat, AI_MATKEY_COLOR_SPECULAR, &aicol) == 0) {
   4.139 +		mat->specular = Vector3(aicol[0], aicol[1], aicol[2]);
   4.140 +	}
   4.141 +
   4.142 +	unsigned int count = 1;
   4.143 +	if(aiGetMaterialFloatArray(aimat, AI_MATKEY_SHININESS_STRENGTH, &shin_str, &count) != 0) {
   4.144 +		shin_str = 1.0;
   4.145 +	}
   4.146 +	if(aiGetMaterialFloatArray(aimat, AI_MATKEY_SHININESS, &shin, &count) == 0) {
   4.147 +		// XXX can't remember how I came up with this...
   4.148 +		mat->shininess = shin * shin_str * 0.0001 * 128.0;
   4.149 +	}
   4.150 +
   4.151 +	// load textures
   4.152 +	struct { int type; aiTextureType aitype; } textypes[] = {
   4.153 +		{TEX_DIFFUSE, aiTextureType_DIFFUSE},
   4.154 +		{TEX_NORMAL, aiTextureType_NORMALS},
   4.155 +		{TEX_SPECULAR, aiTextureType_SPECULAR}
   4.156 +	};
   4.157 +
   4.158 +	for(int i=0; i<sizeof textypes / sizeof *textypes; i++) {
   4.159 +		aiString aipath;
   4.160 +
   4.161 +		if(aiGetMaterialTexture(aimat, textypes[i].aitype, 0, &aipath) == 0) {
   4.162 +			char *tmp, *fname = aipath.data;
   4.163 +
   4.164 +			if((tmp = strrchr(fname, '/'))) {
   4.165 +				fname = tmp + 1;
   4.166 +			}
   4.167 +			if((tmp = strrchr(fname, '\\'))) {
   4.168 +				fname = tmp + 1;
   4.169 +			}
   4.170 +
   4.171 +			if(*fname) {
   4.172 +				mat->tex[textypes[i].type] = texset.get(fname);
   4.173 +			}
   4.174 +		}
   4.175 +	}
   4.176 +
   4.177 +	return true;
   4.178 +}
   4.179 +
   4.180 +static Object *load_node(const aiScene *aiscn, const aiNode *ainode)
   4.181 +{
   4.182 +	Object *obj = new Object;
   4.183 +	obj->set_name(ainode->mName.data);
   4.184 +
   4.185 +	if(ainode->mNumMeshes) {
   4.186 +		if(ainode->mNumMeshes > 1) {
   4.187 +			info_log("%s warning: node %s has more than one meshes (%u)\n", __FUNCTION__,
   4.188 +					ainode->mName.data, ainode->mNumMeshes);
   4.189 +		}
   4.190 +
   4.191 +		aiMesh *aimesh = aiscn->mMeshes[ainode->mMeshes[0]];
   4.192 +		obj->set_mesh(mesh_by_aimesh[aimesh]);
   4.193 +
   4.194 +		// also grab the material of this mesh
   4.195 +		load_material(&obj->material, aiscn->mMaterials[aimesh->mMaterialIndex]);
   4.196 +	}
   4.197 +
   4.198 +	// if there are animations, grab the first and try to use it
   4.199 +	if(aiscn->mNumAnimations) {
   4.200 +		aiAnimation *aianim = aiscn->mAnimations[0];
   4.201 +		aiNodeAnim *ainodeanim = 0;
   4.202 +		for(unsigned int i=0; i<aianim->mNumChannels; i++) {
   4.203 +			if(strcmp(aianim->mChannels[i]->mNodeName.data, ainode->mName.data) == 0) {
   4.204 +				ainodeanim = aianim->mChannels[i];
   4.205 +				break;
   4.206 +			}
   4.207 +		}
   4.208 +
   4.209 +		if(ainodeanim) {
   4.210 +			// load all position (translation) keyframes
   4.211 +			for(unsigned int i=0; i<ainodeanim->mNumPositionKeys; i++) {
   4.212 +				Vector3 pos = assimp_vector(ainodeanim->mPositionKeys[i].mValue);
   4.213 +				long msec = assimp_time(aianim, ainodeanim->mPositionKeys[i].mTime);
   4.214 +				obj->set_position(pos, msec);
   4.215 +			}
   4.216 +
   4.217 +			// load all rotation keyframes
   4.218 +			for(unsigned int i=0; i<ainodeanim->mNumRotationKeys; i++) {
   4.219 +				Quaternion rot = assimp_quat(ainodeanim->mRotationKeys[i].mValue);
   4.220 +				if(rot.length_sq() < SMALL_NUMBER) {
   4.221 +					continue;
   4.222 +				}
   4.223 +				rot.normalize();
   4.224 +				long msec = assimp_time(aianim, ainodeanim->mRotationKeys[i].mTime);
   4.225 +				obj->set_rotation(rot, msec);
   4.226 +			}
   4.227 +
   4.228 +			// load all scaling keyframes
   4.229 +			for(unsigned int i=0; i<ainodeanim->mNumScalingKeys; i++) {
   4.230 +				Vector3 scale = assimp_vector(ainodeanim->mScalingKeys[i].mValue);
   4.231 +				long msec = assimp_time(aianim, ainodeanim->mScalingKeys[i].mTime);
   4.232 +				obj->set_scaling(scale, msec);
   4.233 +			}
   4.234 +
   4.235 +			obj->set_extrapolator(EXTRAP_REPEAT);	// loop animation
   4.236 +		} else {
   4.237 +			Matrix4x4 local_matrix = assimp_matrix(ainode->mTransformation);
   4.238 +			obj->set_local_matrix(local_matrix);
   4.239 +		}
   4.240 +	}
   4.241 +
   4.242 +	/* recurse to all children */
   4.243 +	for(unsigned int i=0; i<ainode->mNumChildren; i++) {
   4.244 +		Object *child = load_node(aiscn, ainode->mChildren[i]);
   4.245 +		if(child) {
   4.246 +			obj->add_child(child);
   4.247 +		}
   4.248 +	}
   4.249 +
   4.250 +	obj_by_name[obj->get_name()] = obj;
   4.251 +	return obj;
   4.252 +}
   4.253 +
   4.254 +static Mesh *load_mesh(const aiScene *aiscn, const aiMesh *aimesh)
   4.255 +{
   4.256 +	Mesh *mesh = new Mesh;
   4.257 +
   4.258 +	int num_verts = aimesh->mNumVertices;
   4.259 +	int num_faces = aimesh->mNumFaces;
   4.260 +
   4.261 +	mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, (float*)aimesh->mVertices);
   4.262 +
   4.263 +	if(aimesh->mNormals) {
   4.264 +		mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, (float*)aimesh->mNormals);
   4.265 +	}
   4.266 +	if(aimesh->mTangents) {
   4.267 +		mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, (float*)aimesh->mTangents);
   4.268 +	}
   4.269 +	if(aimesh->mTextureCoords[0]) {
   4.270 +		mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 3, num_verts, (float*)aimesh->mTextureCoords[0]);
   4.271 +	}
   4.272 +
   4.273 +	if(aimesh->mBones) {
   4.274 +		float *weights = mesh->set_attrib_data(MESH_ATTR_BONEWEIGHTS, 4, num_verts, 0);
   4.275 +		float *boneidx = mesh->set_attrib_data(MESH_ATTR_BONEIDX, 4, num_verts, 0);
   4.276 +
   4.277 +		memset(weights, 0, num_verts * 4 * sizeof *weights);
   4.278 +		memset(boneidx, 0, num_verts * 4 * sizeof *boneidx);
   4.279 +
   4.280 +		int *vertex_bone_count = new int[num_verts];
   4.281 +		memset(vertex_bone_count, 0, num_verts * sizeof *vertex_bone_count);
   4.282 +
   4.283 +		for(unsigned int i=0; i<aimesh->mNumBones; i++) {
   4.284 +			aiBone *aibone = aimesh->mBones[i];
   4.285 +
   4.286 +			// for every vertex affected by this bone:
   4.287 +			for(unsigned int j=0; j<aibone->mNumWeights; j++) {
   4.288 +				aiVertexWeight *aiweight = aibone->mWeights + j;
   4.289 +				int vidx = aiweight->mVertexId;
   4.290 +				int vert_boneidx = vertex_bone_count[vidx];
   4.291 +				if(vert_boneidx >= 4) {
   4.292 +					error_log("WARNING vertex with more than 4 bones found\n");
   4.293 +					continue;
   4.294 +				}
   4.295 +
   4.296 +				weights[vidx * 4 + vert_boneidx] = aiweight->mWeight;
   4.297 +				boneidx[vidx * 4 + vert_boneidx] = (float)i;
   4.298 +				vertex_bone_count[vidx]++;
   4.299 +			}
   4.300 +		}
   4.301 +
   4.302 +		delete [] vertex_bone_count;
   4.303 +
   4.304 +		// normalize weights
   4.305 +		for(int i=0; i<num_verts; i++) {
   4.306 +
   4.307 +			float wsum = 0.0f;
   4.308 +
   4.309 +			for(int j=0; j<4; j++) {
   4.310 +				wsum += weights[i * 4 + j];
   4.311 +			}
   4.312 +
   4.313 +			if(1.0 - wsum > 1e-4) {
   4.314 +				error_log("WARNING vertex with weights < 1 (%f), normalizing...\n", wsum);
   4.315 +
   4.316 +				if(wsum < 1e-6) {
   4.317 +					// this is clearly broken, let's use the first bone in full
   4.318 +					weights[i * 4] = 1.0;
   4.319 +				} else {
   4.320 +					weights[i * 4] /= wsum;
   4.321 +					weights[i * 4 + 1] /= wsum;
   4.322 +					weights[i * 4 + 2] /= wsum;
   4.323 +					weights[i * 4 + 3] /= wsum;
   4.324 +				}
   4.325 +			}
   4.326 +		}
   4.327 +	}
   4.328 +
   4.329 +	unsigned int *iptr = mesh->set_index_data(num_faces * 3);
   4.330 +	for(int i=0; i<num_faces; i++) {
   4.331 +		for(int j=0; j<3; j++) {
   4.332 +			*iptr++ = aimesh->mFaces[i].mIndices[j];
   4.333 +		}
   4.334 +	}
   4.335 +
   4.336 +	return mesh;
   4.337 +}
   4.338 +
   4.339 +static Curve *load_curve(const aiScene *aiscn, const aiMesh *aimesh)
   4.340 +{
   4.341 +	Curve *curve = new Curve;
   4.342 +
   4.343 +	for(unsigned int i=0; i<aimesh->mNumVertices; i++) {
   4.344 +		Vector3 pt = assimp_vector(aimesh->mVertices[i]);
   4.345 +		curve->add_point(pt);
   4.346 +	}
   4.347 +	info_log("loaded curve with %d points\n", aimesh->mNumVertices);
   4.348 +
   4.349 +	return curve;
   4.350 +}
   4.351 +
   4.352 +static bool load_bones(Mesh *mesh, const aiMesh *aimesh)
   4.353 +{
   4.354 +	if(!aimesh->mNumBones) {
   4.355 +		return false;
   4.356 +	}
   4.357 +
   4.358 +	for(unsigned int i=0; i<aimesh->mNumBones; i++) {
   4.359 +		aiBone *aibone = aimesh->mBones[i];
   4.360 +		Object *obj = obj_by_name[aibone->mName.data];
   4.361 +		if(!obj) {
   4.362 +			error_log("bone %s not found\n", aibone->mName.data);
   4.363 +			continue;
   4.364 +		}
   4.365 +
   4.366 +		obj->set_bone_matrix(assimp_matrix(aibone->mOffsetMatrix));
   4.367 +		mesh->add_bone(obj);
   4.368 +
   4.369 +		info_log("adding bone: %s\n", obj->get_name());
   4.370 +	}
   4.371 +
   4.372 +	return true;
   4.373 +}
   4.374 +
   4.375 +static Vector3 assimp_vector(const aiVector3D &v)
   4.376 +{
   4.377 +	return Vector3(v[0], v[1], v[2]);
   4.378 +}
   4.379 +
   4.380 +static Quaternion assimp_quat(const aiQuaternion &q)
   4.381 +{
   4.382 +	return Quaternion(q.w, Vector3(q.x, q.y, q.z));
   4.383 +}
   4.384 +
   4.385 +static Matrix4x4 assimp_matrix(const aiMatrix4x4 &aim)
   4.386 +{
   4.387 +	Matrix4x4 m;
   4.388 +	memcpy(m[0], &aim, 16 * sizeof(float));
   4.389 +	return m;
   4.390 +}
   4.391 +
   4.392 +/* convert an assimp keyframe time (ticks) into milliseconds */
   4.393 +static long assimp_time(const aiAnimation *anim, double aitime)
   4.394 +{
   4.395 +	double sec;
   4.396 +	if(anim->mTicksPerSecond < 1e-6) {
   4.397 +		// assume time is in frames?
   4.398 +		sec = aitime / 30.0;
   4.399 +	} else {
   4.400 +		sec = aitime / anim->mTicksPerSecond;
   4.401 +	}
   4.402 +	return (long)(sec * 1000.0);
   4.403 +}
   4.404 +
   4.405 +static void print_hierarchy(const aiNode *node)
   4.406 +{
   4.407 +	static int lvl;
   4.408 +	static int lvlopen[256];
   4.409 +
   4.410 +	for(int i=0; i<lvl; i++) {
   4.411 +		putchar(' ');
   4.412 +		if(lvlopen[i]) {
   4.413 +			putchar(i >= lvl - 1 ? '+' : '|');
   4.414 +		} else {
   4.415 +			putchar(i >= lvl - 1 ? '+' : ' ');
   4.416 +		}
   4.417 +	}
   4.418 +	info_log("- \"%s\"\n", node->mName.data);
   4.419 +
   4.420 +	lvlopen[lvl] = 1;
   4.421 +
   4.422 +	lvl++;
   4.423 +	for(unsigned int i=0; i<node->mNumChildren; i++) {
   4.424 +		if(i == node->mNumChildren - 1) {
   4.425 +			lvlopen[lvl - 1] = 0;
   4.426 +		}
   4.427 +		print_hierarchy(node->mChildren[i]);
   4.428 +	}
   4.429 +	lvl--;
   4.430 +}
   4.431 +
   4.432 +#else	// !defined USE_ASSIMP
   4.433 +
   4.434 +bool load_ass(Scene *scn, const char *fname)
   4.435 +{
   4.436 +	error_log("load_ass: assimp support not compiled in\n");
   4.437 +	return false;
   4.438 +}
   4.439 +
   4.440 +#endif

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/src/assload.h	Thu Nov 14 05:27:09 2013 +0200
     5.3 @@ -0,0 +1,9 @@
     5.4 +#ifndef ASSLOAD_H_
     5.5 +#define ASSLOAD_H_
     5.6 +
     5.7 +#include <vector>
     5.8 +#include "scene.h"
     5.9 +
    5.10 +bool load_ass(Scene *scn, const char *fname);
    5.11 +
    5.12 +#endif	// ASSLOAD_H_

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/src/curve.cc	Thu Nov 14 05:27:09 2013 +0200
     6.3 @@ -0,0 +1,316 @@
     6.4 +#include <float.h>
     6.5 +#include <assert.h>
     6.6 +#include "curve.h"
     6.7 +#include "opengl.h"
     6.8 +#include "shader.h"
     6.9 +#include "logger.h"
    6.10 +
    6.11 +#define DEF_THICKNESS	0.075
    6.12 +#define DEF_SEGM_SUB	3
    6.13 +#define DEF_RING_SUB	6
    6.14 +
    6.15 +Curve::Curve()
    6.16 +{
    6.17 +	thickness = DEF_THICKNESS;
    6.18 +	mesh_valid = false;
    6.19 +	lengths_valid = false;
    6.20 +
    6.21 +	bbox_valid = false;
    6.22 +
    6.23 +	segm_subdiv = DEF_SEGM_SUB;
    6.24 +	ring_subdiv = DEF_RING_SUB;
    6.25 +}
    6.26 +
    6.27 +Curve::Curve(const Vector3 *points, int num_points)
    6.28 +{
    6.29 +	thickness = DEF_THICKNESS;
    6.30 +	mesh_valid = false;
    6.31 +	lengths_valid = false;
    6.32 +
    6.33 +	bbox_valid = false;
    6.34 +
    6.35 +	segm_subdiv = DEF_SEGM_SUB;
    6.36 +	ring_subdiv = DEF_RING_SUB;
    6.37 +
    6.38 +	for(int i=0; i<num_points; i++) {
    6.39 +		add_point(points[i]);
    6.40 +	}
    6.41 +}
    6.42 +
    6.43 +Curve::Curve(const Vector2 *points, int num_points)
    6.44 +{
    6.45 +	thickness = DEF_THICKNESS;
    6.46 +	mesh_valid = false;
    6.47 +	lengths_valid = false;
    6.48 +
    6.49 +	bbox_valid = false;
    6.50 +
    6.51 +	segm_subdiv = DEF_SEGM_SUB;
    6.52 +	ring_subdiv = DEF_RING_SUB;
    6.53 +
    6.54 +	for(int i=0; i<num_points; i++) {
    6.55 +		add_point(Vector3(points[i].x, points[i].y, 0.0));
    6.56 +	}
    6.57 +}
    6.58 +
    6.59 +void Curve::set_name(const char *name)
    6.60 +{
    6.61 +	this->name = name;
    6.62 +}
    6.63 +
    6.64 +const char *Curve::get_name() const
    6.65 +{
    6.66 +	return name.c_str();
    6.67 +}
    6.68 +
    6.69 +bool Curve::empty() const
    6.70 +{
    6.71 +	return cv.empty();
    6.72 +}
    6.73 +
    6.74 +void Curve::set_thickness(float thickness)
    6.75 +{
    6.76 +	this->thickness = thickness;
    6.77 +}
    6.78 +
    6.79 +void Curve::set_subdiv(int seg, int ring)
    6.80 +{
    6.81 +	if(seg < 1) seg = 1;
    6.82 +	if(ring < 3) ring = 3;
    6.83 +
    6.84 +	segm_subdiv = seg;
    6.85 +	ring_subdiv = ring;
    6.86 +}
    6.87 +
    6.88 +void Curve::clear()
    6.89 +{
    6.90 +	mesh_valid = false;
    6.91 +	lengths_valid = false;
    6.92 +	bbox_valid = false;
    6.93 +	cv.clear();
    6.94 +}
    6.95 +
    6.96 +void Curve::add_point(const Vector3 &pt)
    6.97 +{
    6.98 +	cv.push_back(pt);
    6.99 +	mesh_valid = false;
   6.100 +	lengths_valid = false;
   6.101 +	bbox_valid = false;
   6.102 +}
   6.103 +
   6.104 +Vector3 &Curve::get_point(int idx)
   6.105 +{
   6.106 +	mesh_valid = false;
   6.107 +	lengths_valid = false;
   6.108 +	bbox_valid = false;
   6.109 +	return cv[idx];
   6.110 +}
   6.111 +
   6.112 +const Vector3 &Curve::get_point(int idx) const
   6.113 +{
   6.114 +	return cv[idx];
   6.115 +}
   6.116 +
   6.117 +int Curve::get_count() const
   6.118 +{
   6.119 +	return (int)cv.size();
   6.120 +}
   6.121 +
   6.122 +Vector3 &Curve::operator[] (int idx)
   6.123 +{
   6.124 +	return get_point(idx);
   6.125 +}
   6.126 +
   6.127 +const Vector3 &Curve::operator[] (int idx) const
   6.128 +{
   6.129 +	return get_point(idx);
   6.130 +}
   6.131 +
   6.132 +void Curve::get_bbox(Vector3 *bbmin, Vector3 *bbmax) const
   6.133 +{
   6.134 +	if(!bbox_valid) {
   6.135 +		this->bbmin = Vector3(FLT_MAX, FLT_MAX, FLT_MAX);
   6.136 +		this->bbmax = -this->bbmin;
   6.137 +
   6.138 +		for(size_t i=0; i<cv.size(); i++) {
   6.139 +			for(int j=0; j<3; j++) {
   6.140 +				if(cv[i][j] < this->bbmin[j]) {
   6.141 +					this->bbmin[j] = cv[i][j];
   6.142 +				}
   6.143 +				if(cv[i][j] > this->bbmax[j]) {
   6.144 +					this->bbmax[j] = cv[i][j];
   6.145 +				}
   6.146 +			}
   6.147 +		}
   6.148 +		bbox_valid = true;
   6.149 +	}
   6.150 +
   6.151 +	if(bbmin) *bbmin = this->bbmin;
   6.152 +	if(bbmax) *bbmax = this->bbmax;
   6.153 +}
   6.154 +
   6.155 +void Curve::normalize()
   6.156 +{
   6.157 +	get_bbox(0, 0);	// force validation of the bounding box
   6.158 +
   6.159 +	float len = (bbmax - bbmin).length() * 0.5;
   6.160 +	if(len == 0.0) {
   6.161 +		return;
   6.162 +	}
   6.163 +
   6.164 +	for(size_t i=0; i<cv.size(); i++) {
   6.165 +		get_point(i) /= len;
   6.166 +	}
   6.167 +}
   6.168 +
   6.169 +Vector3 Curve::get_pos(float t) const
   6.170 +{
   6.171 +	if(cv.empty()) {
   6.172 +		return Vector3(0, 0, 0);
   6.173 +	}
   6.174 +	if(cv.size() == 1 || t <= 0.0) {
   6.175 +		return cv[0];
   6.176 +	}
   6.177 +	if(t >= 1.0) {
   6.178 +		return cv.back();
   6.179 +	}
   6.180 +
   6.181 +	t = reparametrize(t);
   6.182 +
   6.183 +	int numcv = (int)cv.size();
   6.184 +	int idx0 = t * (numcv - 1);
   6.185 +	int idx1 = idx0 + 1;
   6.186 +
   6.187 +	int idx_prev = idx0 <= 0 ? idx0 : idx0 - 1;
   6.188 +	int idx_next = idx1 >= numcv - 1 ? idx1 : idx1 + 1;
   6.189 +
   6.190 +	float dt = 1.0 / (float)(numcv - 1);
   6.191 +
   6.192 +	float t0 = (float)idx0 * dt;
   6.193 +	float t1 = (float)idx1 * dt;
   6.194 +
   6.195 +	t = (t - t0) / (t1 - t0);
   6.196 +	if(t < 0.0) t = 0.0;
   6.197 +	if(t > 1.0) t = 1.0;
   6.198 +
   6.199 +	//return catmull_rom_spline(cv[idx_prev], cv[idx0], cv[idx1], cv[idx_next], t);
   6.200 +	return bspline(cv[idx_prev], cv[idx0], cv[idx1], cv[idx_next], t);
   6.201 +}
   6.202 +
   6.203 +Vector3 Curve::operator() (float t) const
   6.204 +{
   6.205 +	return get_pos(t);
   6.206 +}
   6.207 +
   6.208 +void Curve::draw() const
   6.209 +{
   6.210 +	update_mesh();
   6.211 +	if(!mesh_valid) {
   6.212 +		return;
   6.213 +	}
   6.214 +
   6.215 +	mesh.draw();
   6.216 +}
   6.217 +
   6.218 +
   6.219 +float Curve::reparametrize(float t) const
   6.220 +{
   6.221 +	calc_cvlengths();
   6.222 +	return t;	// TODO
   6.223 +}
   6.224 +
   6.225 +void Curve::calc_cvlengths() const
   6.226 +{
   6.227 +	if(lengths_valid || cv.empty()) {
   6.228 +		return;
   6.229 +	}
   6.230 +
   6.231 +	length.clear();
   6.232 +	length.resize(cv.size());
   6.233 +
   6.234 +	length[0] = 0;
   6.235 +	for(size_t i=1; i<cv.size(); i++) {
   6.236 +		length[i] = length[i - 1] + (cv[i] - cv[i - 1]).length();
   6.237 +	}
   6.238 +
   6.239 +	lengths_valid = true;
   6.240 +}
   6.241 +
   6.242 +void Curve::update_mesh() const
   6.243 +{
   6.244 +	if(mesh_valid) return;
   6.245 +
   6.246 +	if(cv.size() < 2) {
   6.247 +		return;
   6.248 +	}
   6.249 +
   6.250 +	mesh.clear();
   6.251 +
   6.252 +	int nsub = segm_subdiv * (cv.size() - 1);
   6.253 +	int num_rings = nsub + 1;
   6.254 +
   6.255 +	int num_verts = ring_subdiv * num_rings;
   6.256 +	int num_quads = ring_subdiv * nsub;
   6.257 +	int num_tri = num_quads * 2;
   6.258 +	int num_idx = num_tri * 3;
   6.259 +
   6.260 +	float *varr = mesh.set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts);
   6.261 +	float *narr = mesh.set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts);
   6.262 +	float *tcarr = mesh.set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts);
   6.263 +	unsigned int *idxarr = mesh.set_index_data(num_idx);
   6.264 +
   6.265 +	float t = 0.0;
   6.266 +	float dt = 1.0 / (float)(num_rings - 1);
   6.267 +
   6.268 +	for(int i=0; i<num_rings; i++) {
   6.269 +		Vector3 p = get_pos(t);
   6.270 +		Vector3 dir = (get_pos(t + dt) - p).normalized();
   6.271 +
   6.272 +		Vector3 up = Vector3(0, 0, 1);
   6.273 +		float updotdir = dot_product(up, dir);
   6.274 +		if(1.0 - fabs(updotdir) < 1e-4) {
   6.275 +			up = Vector3(0, 1, 0);
   6.276 +		}
   6.277 +		Vector3 right = cross_product(up, dir).normalized();
   6.278 +		up = cross_product(dir, right);
   6.279 +
   6.280 +		for(int j=0; j<ring_subdiv; j++) {
   6.281 +			float u = (float)j / (float)ring_subdiv * M_PI * 2.0;
   6.282 +			Quaternion qrot(dir, u);
   6.283 +			Vector3 v = p + right.transformed(qrot) * thickness;
   6.284 +
   6.285 +			*varr++ = v.x;
   6.286 +			*varr++ = v.y;
   6.287 +			*varr++ = v.z;
   6.288 +
   6.289 +			Vector3 norm = (v - p).normalized();
   6.290 +			*narr++ = norm.x;
   6.291 +			*narr++ = norm.y;
   6.292 +			*narr++ = norm.z;
   6.293 +
   6.294 +			*tcarr++ = u;
   6.295 +			*tcarr++ = t;
   6.296 +
   6.297 +			if(i < nsub) {
   6.298 +				int quad = i * ring_subdiv + j;
   6.299 +
   6.300 +				int v0 = quad;
   6.301 +				int v1 = i * ring_subdiv + ((j + 1) % ring_subdiv);
   6.302 +				int v2 = (i + 1) * ring_subdiv + ((j + 1) % ring_subdiv);
   6.303 +				int v3 = (i + 1) * ring_subdiv + j;
   6.304 +
   6.305 +				idxarr[quad * 6] = v0;
   6.306 +				idxarr[quad * 6 + 1] = v1;
   6.307 +				idxarr[quad * 6 + 2] = v2;
   6.308 +
   6.309 +				idxarr[quad * 6 + 3] = v0;
   6.310 +				idxarr[quad * 6 + 4] = v2;
   6.311 +				idxarr[quad * 6 + 5] = v3;
   6.312 +			}
   6.313 +		}
   6.314 +
   6.315 +		t += dt;
   6.316 +	}
   6.317 +
   6.318 +	mesh_valid = true;
   6.319 +}

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/src/curve.h	Thu Nov 14 05:27:09 2013 +0200
     7.3 @@ -0,0 +1,64 @@
     7.4 +#ifndef CURVE_H_
     7.5 +#define CURVE_H_
     7.6 +
     7.7 +#include <string>
     7.8 +#include <vector>
     7.9 +#include "vmath/vmath.h"
    7.10 +#include "mesh.h"
    7.11 +
    7.12 +class Curve {
    7.13 +private:
    7.14 +	std::string name;
    7.15 +
    7.16 +	std::vector<Vector3> cv;
    7.17 +	float thickness;
    7.18 +
    7.19 +	int segm_subdiv, ring_subdiv;
    7.20 +
    7.21 +	/// normalized arc-lengths of each control vertex from the beginning
    7.22 +	mutable std::vector<float> length;
    7.23 +	mutable bool lengths_valid;
    7.24 +
    7.25 +	mutable Vector3 bbmin, bbmax;
    7.26 +	mutable bool bbox_valid;
    7.27 +
    7.28 +	mutable Mesh mesh;
    7.29 +	mutable bool mesh_valid;
    7.30 +
    7.31 +	float reparametrize(float t) const;
    7.32 +
    7.33 +	void calc_cvlengths() const;
    7.34 +	void update_mesh() const;
    7.35 +
    7.36 +public:
    7.37 +	Curve();
    7.38 +	Curve(const Vector3 *points, int num_points);
    7.39 +	Curve(const Vector2 *points, int num_points);
    7.40 +
    7.41 +	void set_name(const char *name);
    7.42 +	const char *get_name() const;
    7.43 +
    7.44 +	bool empty() const;
    7.45 +
    7.46 +	void set_thickness(float thickness);
    7.47 +	void set_subdiv(int seg, int ring);
    7.48 +
    7.49 +	void clear();
    7.50 +	void add_point(const Vector3 &pt);
    7.51 +	Vector3 &get_point(int idx);
    7.52 +	const Vector3 &get_point(int idx) const;
    7.53 +	int get_count() const;
    7.54 +
    7.55 +	Vector3 &operator[] (int idx);
    7.56 +	const Vector3 &operator[] (int idx) const;
    7.57 +
    7.58 +	void get_bbox(Vector3 *bbmin, Vector3 *bbmax) const;
    7.59 +	void normalize();
    7.60 +
    7.61 +	Vector3 get_pos(float t) const;
    7.62 +	Vector3 operator() (float t) const;
    7.63 +
    7.64 +	void draw() const;
    7.65 +};
    7.66 +
    7.67 +#endif	// CURVE_H_

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/curveload.cc	Thu Nov 14 05:27:09 2013 +0200
     8.3 @@ -0,0 +1,195 @@
     8.4 +#include <string>
     8.5 +#include <assert.h>
     8.6 +#include <stdint.h>
     8.7 +#include "curveload.h"
     8.8 +#include "3dschunks.h"
     8.9 +#include "logger.h"
    8.10 +
    8.11 +static uint32_t read_counter;
    8.12 +
    8.13 +struct ChunkHeader {
    8.14 +	ChunkID id;
    8.15 +	uint32_t size;
    8.16 +};
    8.17 +
    8.18 +#define HEADER_SIZE		6
    8.19 +
    8.20 +// local function prototypes
    8.21 +static uint8_t read_byte(FILE *file);
    8.22 +static uint16_t read_int16(FILE *file);
    8.23 +static uint32_t read_int32(FILE *file);
    8.24 +static float read_float(FILE *file);
    8.25 +static Vector3 read_vector(FILE *file, bool flip_yz = false);
    8.26 +static std::string read_string(FILE *file);
    8.27 +static ChunkHeader read_chunk_header(FILE *file);
    8.28 +static void skip_chunk(FILE *file, const ChunkHeader &chunk);
    8.29 +static Curve *read_curve(FILE *file, const ChunkHeader &ch);
    8.30 +
    8.31 +static bool eof;
    8.32 +
    8.33 +bool load_curves(Scene *scn, const char *fname)
    8.34 +{
    8.35 +	FILE *file = fopen(fname, "rb");
    8.36 +	if(!file) {
    8.37 +		error_log("failed to open curves scene file: %s\n", fname);
    8.38 +		return false;
    8.39 +	}
    8.40 +	eof = false;
    8.41 +
    8.42 +	ChunkHeader chunk;
    8.43 +
    8.44 +	chunk = read_chunk_header(file);
    8.45 +	if(chunk.id != Chunk_3DSMain) {
    8.46 +		fclose(file);
    8.47 +		return false;
    8.48 +	}
    8.49 +
    8.50 +	while(!eof) {
    8.51 +		chunk = read_chunk_header(file);
    8.52 +
    8.53 +		Curve *curve;
    8.54 +
    8.55 +		switch(chunk.id) {
    8.56 +		case Chunk_Main_3DEditor:
    8.57 +			break;	// dont skip
    8.58 +
    8.59 +		case Chunk_Edit_Object:
    8.60 +			if((curve = read_curve(file, chunk))) {
    8.61 +				scn->curves.push_back(curve);
    8.62 +			}
    8.63 +			break;
    8.64 +
    8.65 +		default:
    8.66 +			skip_chunk(file, chunk);
    8.67 +		}
    8.68 +	}
    8.69 +
    8.70 +	fclose(file);
    8.71 +    return true;
    8.72 +}
    8.73 +
    8.74 +static uint8_t read_byte(FILE *fp) {
    8.75 +	uint8_t v;
    8.76 +	if(fread(&v, 1, 1, fp) <= 0) {
    8.77 +		eof = true;
    8.78 +		return 0;
    8.79 +	}
    8.80 +	read_counter++;
    8.81 +	return v;
    8.82 +}
    8.83 +
    8.84 +static uint16_t read_int16(FILE *fp) {
    8.85 +	uint16_t v;
    8.86 +	if(fread(&v, 2, 1, fp) <= 0) {
    8.87 +		eof = true;
    8.88 +		return 0;
    8.89 +	}
    8.90 +	read_counter += 2;
    8.91 +	return v;
    8.92 +}
    8.93 +
    8.94 +static uint32_t read_int32(FILE *fp) {
    8.95 +	uint32_t v;
    8.96 +	if(fread(&v, 4, 1, fp) <= 0) {
    8.97 +		eof = true;
    8.98 +		return 0;
    8.99 +	}
   8.100 +	read_counter += 4;
   8.101 +	return v;
   8.102 +}
   8.103 +
   8.104 +static float read_float(FILE *fp)
   8.105 +{
   8.106 +	int32_t tmp = read_int32(fp);
   8.107 +	return *((float*)&tmp);
   8.108 +}
   8.109 +
   8.110 +static Vector3 read_vector(FILE *file, bool flip_yz)
   8.111 +{
   8.112 +	Vector3 vector;
   8.113 +	vector.x = read_float(file);
   8.114 +	if(!flip_yz) vector.y = read_float(file);
   8.115 +	vector.z = read_float(file);
   8.116 +	if(flip_yz) vector.y = read_float(file);
   8.117 +	return vector;
   8.118 +}
   8.119 +
   8.120 +static std::string read_string(FILE *file)
   8.121 +{
   8.122 +	std::string str;
   8.123 +	char c;
   8.124 +	while((c = (char)read_byte(file))) {
   8.125 +		str.push_back(c);
   8.126 +	}
   8.127 +	read_counter++;
   8.128 +
   8.129 +	return str;
   8.130 +}
   8.131 +
   8.132 +static ChunkHeader read_chunk_header(FILE *file)
   8.133 +{
   8.134 +	ChunkHeader chunk;
   8.135 +	chunk.id = (ChunkID)read_int16(file);
   8.136 +	chunk.size = read_int32(file);
   8.137 +	return chunk;
   8.138 +}
   8.139 +
   8.140 +static void skip_chunk(FILE *file, const ChunkHeader &chunk)
   8.141 +{
   8.142 +	if(eof) return;
   8.143 +	fseek(file, chunk.size - HEADER_SIZE, SEEK_CUR);
   8.144 +	read_counter += chunk.size - HEADER_SIZE;
   8.145 +}
   8.146 +
   8.147 +static Curve *read_curve(FILE *file, const ChunkHeader &ch)
   8.148 +{
   8.149 +	read_counter = HEADER_SIZE;	// reset the global read counter
   8.150 +
   8.151 +	std::string name = read_string(file);
   8.152 +
   8.153 +	ChunkHeader chunk;
   8.154 +	chunk = read_chunk_header(file);
   8.155 +	if(chunk.id == Chunk_Obj_TriMesh) {
   8.156 +		// object is a trimesh... load it
   8.157 +		Vector3 *varray = 0;
   8.158 +		uint32_t vertex_count = 0;
   8.159 +
   8.160 +		uint32_t obj_chunk_size = ch.size;
   8.161 +
   8.162 +		while(read_counter < obj_chunk_size) {	// make sure we only read subchunks of this object chunk
   8.163 +			chunk = read_chunk_header(file);
   8.164 +
   8.165 +            switch(chunk.id) {
   8.166 +			case Chunk_TriMesh_VertexList:
   8.167 +				vertex_count = (uint32_t)read_int16(file);
   8.168 +				varray = new Vector3[vertex_count];
   8.169 +
   8.170 +				for(uint32_t i=0; i<vertex_count; i++) {
   8.171 +					varray[i] = read_vector(file);
   8.172 +				}
   8.173 +
   8.174 +				break;
   8.175 +
   8.176 +			case Chunk_TriMesh_FaceDesc:
   8.177 +				// it is a real object not a curve since it has triangles
   8.178 +				delete [] varray;
   8.179 +				varray = 0;
   8.180 +				break;
   8.181 +
   8.182 +			default:
   8.183 +				skip_chunk(file, chunk);
   8.184 +			}
   8.185 +		}
   8.186 +
   8.187 +		if(varray) {
   8.188 +			Curve *curve = new Curve;
   8.189 +			curve->set_name(name.c_str());
   8.190 +			for(uint32_t i=0; i<vertex_count; i++) {
   8.191 +				curve->add_point(varray[i]);
   8.192 +			}
   8.193 +			return curve;
   8.194 +		}
   8.195 +	}
   8.196 +
   8.197 +	return 0;
   8.198 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/src/curveload.h	Thu Nov 14 05:27:09 2013 +0200
     9.3 @@ -0,0 +1,8 @@
     9.4 +#ifndef CURVELOAD_H_
     9.5 +#define CURVELOAD_H_
     9.6 +
     9.7 +#include "scene.h"
     9.8 +
     9.9 +bool load_curves(Scene *scn, const char *fname);
    9.10 +
    9.11 +#endif	// CURVELOAD_H_

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/src/datapath.cc	Thu Nov 14 05:27:09 2013 +0200
    10.3 @@ -0,0 +1,67 @@
    10.4 +#include <stdio.h>
    10.5 +#include <set>
    10.6 +#include <string>
    10.7 +#include "logger.h"
    10.8 +#include "datapath.h"
    10.9 +
   10.10 +static std::set<std::string> paths;
   10.11 +
   10.12 +void add_data_path(const char *path)
   10.13 +{
   10.14 +	paths.insert(path);
   10.15 +}
   10.16 +
   10.17 +#ifndef TARGET_IPHONE
   10.18 +std::string datafile_path(const char *fname)
   10.19 +{
   10.20 +	std::string res;
   10.21 +	if(!fname) {
   10.22 +		return res;
   10.23 +	}
   10.24 +
   10.25 +	std::set<std::string>::const_iterator it = paths.begin();
   10.26 +	while(it != paths.end()) {
   10.27 +		const std::string &path = *it++;
   10.28 +		res = path + "/" + std::string(fname);
   10.29 +		FILE *fp = fopen(res.c_str(), "r");
   10.30 +		if(fp) {
   10.31 +			fclose(fp);
   10.32 +			return res;
   10.33 +		}
   10.34 +	}
   10.35 +
   10.36 +	// It's not found. Return the name itself just in case it's right here
   10.37 +	return std::string(fname);
   10.38 +}
   10.39 +#else
   10.40 +#include <CoreFoundation/CoreFoundation.h>
   10.41 +
   10.42 +std::string datafile_path(const char *fname)
   10.43 +{
   10.44 +	std::string res;
   10.45 +	if(!fname) {
   10.46 +		return res;
   10.47 +	}
   10.48 +
   10.49 +	CFBundleRef bundle;
   10.50 +	CFURLRef url;
   10.51 +	CFStringRef cfname;
   10.52 +
   10.53 +	cfname = CFStringCreateWithCString(0, fname, kCFStringEncodingASCII);
   10.54 +
   10.55 +	bundle = CFBundleGetMainBundle();
   10.56 +	if(!(url = CFBundleCopyResourceURL(bundle, cfname, 0, 0))) {
   10.57 +		CFRelease(cfname);
   10.58 +		return fname;
   10.59 +	}
   10.60 +	CFRelease(cfname);
   10.61 +
   10.62 +	char path[1024];
   10.63 +	if(!CFURLGetFileSystemRepresentation(url, 1, (unsigned char*)path, sizeof path)) {
   10.64 +		CFRelease(url);
   10.65 +		return fname;
   10.66 +	}
   10.67 +	CFRelease(url);
   10.68 +	return std::string(path);
   10.69 +}
   10.70 +#endif

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/src/datapath.h	Thu Nov 14 05:27:09 2013 +0200
    11.3 @@ -0,0 +1,10 @@
    11.4 +#ifndef DATAPATH_H_
    11.5 +#define DATAPATH_H_
    11.6 +
    11.7 +#include <string>
    11.8 +
    11.9 +void add_data_path(const char *path);
   11.10 +
   11.11 +std::string datafile_path(const char *fname);
   11.12 +
   11.13 +#endif	// DATAPATH_H_

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/src/dataset.h	Thu Nov 14 05:27:09 2013 +0200
    12.3 @@ -0,0 +1,44 @@
    12.4 +/** DataSet is a generic resource database with fast O(logn) lookups by name
    12.5 + * it can be used for texture managers, mesh managers, sound effect managers etc
    12.6 + *
    12.7 + * The constructor takes a load function and a destructor function to be called
    12.8 + * when a nonexistent resource is requested and needs to be loaded, and when
    12.9 + * the DataSet is destroyed. The destructor is optional and can be set to null
   12.10 + * if not needed.
   12.11 + *
   12.12 + * Requesting a resource works by simply calling get, example:
   12.13 + * ----------------------------------------------------------
   12.14 + * \code
   12.15 + * Texture *load_texture(const char *fname);
   12.16 + * void free_texture(Texture *tex);
   12.17 + *
   12.18 + * DataSet<Texture*> texman(load_texture, free_texture);
   12.19 + * Texture *foo = texman.get("foo.png");
   12.20 + * \endcode
   12.21 + */
   12.22 +#ifndef DATASET_H_
   12.23 +#define DATASET_H_
   12.24 +
   12.25 +#include <string>
   12.26 +#include <map>
   12.27 +
   12.28 +template <typename T>
   12.29 +class DataSet {
   12.30 +protected:
   12.31 +	mutable std::map<std::string, T> data;
   12.32 +
   12.33 +	T (*load)(const char*);
   12.34 +	void (*destroy)(T);
   12.35 +
   12.36 +public:
   12.37 +	DataSet(T (*load_func)(const char*), void (*destr_func)(T) = 0);
   12.38 +	~DataSet();
   12.39 +
   12.40 +	void clear();
   12.41 +
   12.42 +	T get(const char *name) const;
   12.43 +};
   12.44 +
   12.45 +#include "dataset.inl"
   12.46 +
   12.47 +#endif	// DATASET_H_

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/src/dataset.inl	Thu Nov 14 05:27:09 2013 +0200
    13.3 @@ -0,0 +1,56 @@
    13.4 +#include <stdio.h>
    13.5 +#include <string.h>
    13.6 +#include "datapath.h"
    13.7 +
    13.8 +template <typename T>
    13.9 +DataSet<T>::DataSet(T (*load_func)(const char*), void (*destr_func)(T))
   13.10 +{
   13.11 +	load = load_func;
   13.12 +	destroy = destr_func;
   13.13 +}
   13.14 +
   13.15 +template <typename T>
   13.16 +DataSet<T>::~DataSet()
   13.17 +{
   13.18 +	clear();
   13.19 +}
   13.20 +
   13.21 +template <typename T>
   13.22 +void DataSet<T>::clear()
   13.23 +{
   13.24 +	if(destroy) {
   13.25 +		typename std::map<std::string, T>::iterator it = data.begin();
   13.26 +		while(it != data.end()) {
   13.27 +			destroy(it++->second);
   13.28 +		}
   13.29 +	}
   13.30 +	data.clear();
   13.31 +}
   13.32 +
   13.33 +template <typename T>
   13.34 +T DataSet<T>::get(const char *name) const
   13.35 +{
   13.36 +	typename std::map<std::string, T>::const_iterator iter = data.find(name);
   13.37 +	if(iter != data.end()) {
   13.38 +		return iter->second;
   13.39 +	}
   13.40 +
   13.41 +	const char *fname, *slash;
   13.42 +	if((slash = strrchr(name, '/'))) {
   13.43 +		fname = slash + 1;
   13.44 +	} else {
   13.45 +		fname = name;
   13.46 +	}
   13.47 +
   13.48 +	std::string path = datafile_path(fname);
   13.49 +	if(path.empty()) {
   13.50 +		fprintf(stderr, "can't find data file: %s\n", name);
   13.51 +		return 0;
   13.52 +	}
   13.53 +
   13.54 +	T res = load(path.c_str());
   13.55 +	if(res) {
   13.56 +		data[name] = res;
   13.57 +	}
   13.58 +	return res;
   13.59 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/src/geom.cc	Thu Nov 14 05:27:09 2013 +0200
    14.3 @@ -0,0 +1,252 @@
    14.4 +#include <algorithm>
    14.5 +#include <float.h>
    14.6 +#include "geom.h"
    14.7 +#include "logger.h"
    14.8 +
    14.9 +GeomObject::~GeomObject()
   14.10 +{
   14.11 +}
   14.12 +
   14.13 +
   14.14 +Sphere::Sphere()
   14.15 +{
   14.16 +	radius = 1.0;
   14.17 +}
   14.18 +
   14.19 +Sphere::Sphere(const Vector3 &cent, float radius)
   14.20 +	: center(cent)
   14.21 +{
   14.22 +	this->radius = radius;
   14.23 +}
   14.24 +
   14.25 +void Sphere::set_union(const GeomObject *obj1, const GeomObject *obj2)
   14.26 +{
   14.27 +	const Sphere *sph1 = dynamic_cast<const Sphere*>(obj1);
   14.28 +	const Sphere *sph2 = dynamic_cast<const Sphere*>(obj2);
   14.29 +
   14.30 +	if(!sph1 || !sph2) {
   14.31 +		error_log("Sphere::set_union: arguments must be spheres");
   14.32 +		return;
   14.33 +	}
   14.34 +
   14.35 +	float dist = (sph1->center - sph2->center).length();
   14.36 +	float surf_dist = dist - (sph1->radius + sph2->radius);
   14.37 +	float d1 = sph1->radius + surf_dist / 2.0;
   14.38 +	float d2 = sph2->radius + surf_dist / 2.0;
   14.39 +	float t = d1 / (d1 + d2);
   14.40 +
   14.41 +	if(t < 0.0) t = 0.0;
   14.42 +	if(t > 1.0) t = 1.0;
   14.43 +
   14.44 +	center = sph1->center * t + sph2->center * (1.0 - t);
   14.45 +	radius = std::max(dist * t + sph2->radius, dist * (1.0f - t) + sph1->radius);
   14.46 +}
   14.47 +
   14.48 +void Sphere::set_intersection(const GeomObject *obj1, const GeomObject *obj2)
   14.49 +{
   14.50 +	error_log("Sphere::intersection undefined\n");
   14.51 +}
   14.52 +
   14.53 +bool Sphere::intersect(const Ray &ray, HitPoint *hit) const
   14.54 +{
   14.55 +	float a = dot_product(ray.dir, ray.dir);
   14.56 +	float b = 2.0 * ray.dir.x * (ray.origin.x - center.x) +
   14.57 +		2.0 * ray.dir.y * (ray.origin.y - center.y) +
   14.58 +		2.0 * ray.dir.z * (ray.origin.z - center.z);
   14.59 +	float c = dot_product(ray.origin, ray.origin) + dot_product(center, center) -
   14.60 +		2.0 * dot_product(ray.origin, center) - radius * radius;
   14.61 +
   14.62 +	float discr = b * b - 4.0 * a * c;
   14.63 +	if(discr < 1e-4) {
   14.64 +		return false;
   14.65 +	}
   14.66 +
   14.67 +	float sqrt_discr = sqrt(discr);
   14.68 +	float t0 = (-b + sqrt_discr) / (2.0 * a);
   14.69 +	float t1 = (-b - sqrt_discr) / (2.0 * a);
   14.70 +
   14.71 +	if(t0 < 1e-4)
   14.72 +		t0 = t1;
   14.73 +	if(t1 < 1e-4)
   14.74 +		t1 = t0;
   14.75 +
   14.76 +	float t = t0 < t1 ? t0 : t1;
   14.77 +	if(t < 1e-4) {
   14.78 +		return false;
   14.79 +	}
   14.80 +
   14.81 +	// fill the HitPoint structure
   14.82 +	if(hit) {
   14.83 +		hit->obj = this;
   14.84 +		hit->dist = t;
   14.85 +		hit->pos = ray.origin + ray.dir * t;
   14.86 +		hit->normal = (hit->pos - center) / radius;
   14.87 +	}
   14.88 +	return true;
   14.89 +}
   14.90 +
   14.91 +
   14.92 +AABox::AABox()
   14.93 +{
   14.94 +}
   14.95 +
   14.96 +AABox::AABox(const Vector3 &vmin, const Vector3 &vmax)
   14.97 +	: min(vmin), max(vmax)
   14.98 +{
   14.99 +}
  14.100 +
  14.101 +void AABox::set_union(const GeomObject *obj1, const GeomObject *obj2)
  14.102 +{
  14.103 +	const AABox *box1 = dynamic_cast<const AABox*>(obj1);
  14.104 +	const AABox *box2 = dynamic_cast<const AABox*>(obj2);
  14.105 +
  14.106 +	if(!box1 || !box2) {
  14.107 +		error_log("AABox::set_union: arguments must be AABoxes too\n");
  14.108 +		return;
  14.109 +	}
  14.110 +
  14.111 +	min.x = std::min(box1->min.x, box2->min.x);
  14.112 +	min.y = std::min(box1->min.y, box2->min.y);
  14.113 +	min.z = std::min(box1->min.z, box2->min.z);
  14.114 +
  14.115 +	max.x = std::max(box1->max.x, box2->max.x);
  14.116 +	max.y = std::max(box1->max.y, box2->max.y);
  14.117 +	max.z = std::max(box1->max.z, box2->max.z);
  14.118 +}
  14.119 +
  14.120 +void AABox::set_intersection(const GeomObject *obj1, const GeomObject *obj2)
  14.121 +{
  14.122 +	const AABox *box1 = dynamic_cast<const AABox*>(obj1);
  14.123 +	const AABox *box2 = dynamic_cast<const AABox*>(obj2);
  14.124 +
  14.125 +	if(!box1 || !box2) {
  14.126 +		error_log("AABox::set_intersection: arguments must be AABoxes too\n");
  14.127 +		return;
  14.128 +	}
  14.129 +
  14.130 +	for(int i=0; i<3; i++) {
  14.131 +		min[i] = std::max(box1->min[i], box2->min[i]);
  14.132 +		max[i] = std::min(box1->max[i], box2->max[i]);
  14.133 +
  14.134 +		if(max[i] < min[i]) {
  14.135 +			max[i] = min[i];
  14.136 +		}
  14.137 +	}
  14.138 +}
  14.139 +
  14.140 +bool AABox::intersect(const Ray &ray, HitPoint *hit) const
  14.141 +{
  14.142 +	Vector3 param[2] = {min, max};
  14.143 +	Vector3 inv_dir(1.0 / ray.dir.x, 1.0 / ray.dir.y, 1.0 / ray.dir.z);
  14.144 +	int sign[3] = {inv_dir.x < 0, inv_dir.y < 0, inv_dir.z < 0};
  14.145 +
  14.146 +	float tmin = (param[sign[0]].x - ray.origin.x) * inv_dir.x;
  14.147 +	float tmax = (param[1 - sign[0]].x - ray.origin.x) * inv_dir.x;
  14.148 +	float tymin = (param[sign[1]].y - ray.origin.y) * inv_dir.y;
  14.149 +	float tymax = (param[1 - sign[1]].y - ray.origin.y) * inv_dir.y;
  14.150 +
  14.151 +	if(tmin > tymax || tymin > tmax) {
  14.152 +		return false;
  14.153 +	}
  14.154 +	if(tymin > tmin) {
  14.155 +		tmin = tymin;
  14.156 +	}
  14.157 +	if(tymax < tmax) {
  14.158 +		tmax = tymax;
  14.159 +	}
  14.160 +
  14.161 +	float tzmin = (param[sign[2]].z - ray.origin.z) * inv_dir.z;
  14.162 +	float tzmax = (param[1 - sign[2]].z - ray.origin.z) * inv_dir.z;
  14.163 +
  14.164 +	if(tmin > tzmax || tzmin > tmax) {
  14.165 +		return false;
  14.166 +	}
  14.167 +	if(tzmin > tmin) {
  14.168 +		tmin = tzmin;
  14.169 +	}
  14.170 +	if(tzmax < tmax) {
  14.171 +		tmax = tzmax;
  14.172 +	}
  14.173 +
  14.174 +	float t = tmin < 1e-4 ? tmax : tmin;
  14.175 +	if(t >= 1e-4) {
  14.176 +
  14.177 +		if(hit) {
  14.178 +			hit->obj = this;
  14.179 +			hit->dist = t;
  14.180 +			hit->pos = ray.origin + ray.dir * t;
  14.181 +
  14.182 +			float min_dist = FLT_MAX;
  14.183 +			Vector3 offs = min + (max - min) / 2.0;
  14.184 +			Vector3 local_hit = hit->pos - offs;
  14.185 +
  14.186 +			static const Vector3 axis[] = {
  14.187 +				Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, 1)
  14.188 +			};
  14.189 +			//int tcidx[][2] = {{2, 1}, {0, 2}, {0, 1}};
  14.190 +
  14.191 +			for(int i=0; i<3; i++) {
  14.192 +				float dist = fabs((max[i] - offs[i]) - fabs(local_hit[i]));
  14.193 +				if(dist < min_dist) {
  14.194 +					min_dist = dist;
  14.195 +					hit->normal = axis[i] * (local_hit[i] < 0.0 ? 1.0 : -1.0);
  14.196 +					//hit->texcoord = Vector2(hit->pos[tcidx[i][0]], hit->pos[tcidx[i][1]]);
  14.197 +				}
  14.198 +			}
  14.199 +		}
  14.200 +		return true;
  14.201 +	}
  14.202 +	return false;
  14.203 +
  14.204 +}
  14.205 +
  14.206 +Plane::Plane()
  14.207 +	: normal(0.0, 1.0, 0.0)
  14.208 +{
  14.209 +}
  14.210 +
  14.211 +Plane::Plane(const Vector3 &p, const Vector3 &norm)
  14.212 +	: pt(p)
  14.213 +{
  14.214 +	normal = norm.normalized();
  14.215 +}
  14.216 +
  14.217 +Plane::Plane(const Vector3 &p1, const Vector3 &p2, const Vector3 &p3)
  14.218 +	: pt(p1)
  14.219 +{
  14.220 +	normal = cross_product(p2 - p1, p3 - p1).normalized();
  14.221 +}
  14.222 +
  14.223 +Plane::Plane(const Vector3 &normal, float dist)
  14.224 +{
  14.225 +	this->normal = normal.normalized();
  14.226 +	pt = this->normal * dist;
  14.227 +}
  14.228 +
  14.229 +void Plane::set_union(const GeomObject *obj1, const GeomObject *obj2)
  14.230 +{
  14.231 +	error_log("Plane::set_union undefined\n");
  14.232 +}
  14.233 +
  14.234 +void Plane::set_intersection(const GeomObject *obj1, const GeomObject *obj2)
  14.235 +{
  14.236 +	error_log("Plane::set_intersection undefined\n");
  14.237 +}
  14.238 +
  14.239 +bool Plane::intersect(const Ray &ray, HitPoint *hit) const
  14.240 +{
  14.241 +	float ndotdir = dot_product(normal, ray.dir);
  14.242 +	if(fabs(ndotdir) < 1e-4) {
  14.243 +		return false;
  14.244 +	}
  14.245 +
  14.246 +	if(hit) {
  14.247 +		Vector3 ptdir = pt - ray.origin;
  14.248 +		float t = dot_product(normal, ptdir) / ndotdir;
  14.249 +
  14.250 +		hit->pos = ray.origin + ray.dir * t;
  14.251 +		hit->normal = normal;
  14.252 +		hit->obj = this;
  14.253 +	}
  14.254 +	return true;
  14.255 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/src/geom.h	Thu Nov 14 05:27:09 2013 +0200
    15.3 @@ -0,0 +1,67 @@
    15.4 +#ifndef GEOMOBJ_H_
    15.5 +#define GEOMOBJ_H_
    15.6 +
    15.7 +#include "vmath/vmath.h"
    15.8 +
    15.9 +class GeomObject;
   15.10 +
   15.11 +struct HitPoint {
   15.12 +	float dist;				//< parametric distance along the ray
   15.13 +	Vector3 pos;			//< position of intersection (orig + dir * dist)
   15.14 +	Vector3 normal;			//< normal at the point of intersection
   15.15 +	const void *obj;		//< pointer to the intersected object
   15.16 +};
   15.17 +
   15.18 +class GeomObject {
   15.19 +public:
   15.20 +	virtual ~GeomObject();
   15.21 +
   15.22 +	virtual void set_union(const GeomObject *obj1, const GeomObject *obj2) = 0;
   15.23 +	virtual void set_intersection(const GeomObject *obj1, const GeomObject *obj2) = 0;
   15.24 +
   15.25 +	virtual bool intersect(const Ray &ray, HitPoint *hit = 0) const = 0;
   15.26 +};
   15.27 +
   15.28 +class Sphere : public GeomObject {
   15.29 +public:
   15.30 +	Vector3 center;
   15.31 +	float radius;
   15.32 +
   15.33 +	Sphere();
   15.34 +	Sphere(const Vector3 &center, float radius);
   15.35 +
   15.36 +	void set_union(const GeomObject *obj1, const GeomObject *obj2);
   15.37 +	void set_intersection(const GeomObject *obj1, const GeomObject *obj2);
   15.38 +
   15.39 +	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
   15.40 +};
   15.41 +
   15.42 +class AABox : public GeomObject {
   15.43 +public:
   15.44 +	Vector3 min, max;
   15.45 +
   15.46 +	AABox();
   15.47 +	AABox(const Vector3 &min, const Vector3 &max);
   15.48 +
   15.49 +	void set_union(const GeomObject *obj1, const GeomObject *obj2);
   15.50 +	void set_intersection(const GeomObject *obj1, const GeomObject *obj2);
   15.51 +
   15.52 +	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
   15.53 +};
   15.54 +
   15.55 +class Plane : public GeomObject {
   15.56 +public:
   15.57 +	Vector3 pt, normal;
   15.58 +
   15.59 +	Plane();
   15.60 +	Plane(const Vector3 &pt, const Vector3 &normal);
   15.61 +	Plane(const Vector3 &p1, const Vector3 &p2, const Vector3 &p3);
   15.62 +	Plane(const Vector3 &normal, float dist);
   15.63 +
   15.64 +	void set_union(const GeomObject *obj1, const GeomObject *obj2);
   15.65 +	void set_intersection(const GeomObject *obj1, const GeomObject *obj2);
   15.66 +
   15.67 +	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
   15.68 +};
   15.69 +
   15.70 +#endif	// GEOMOBJ_H_

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/src/gfxutil.cc	Thu Nov 14 05:27:09 2013 +0200
    16.3 @@ -0,0 +1,64 @@
    16.4 +#include <assert.h>
    16.5 +#include "gfxutil.h"
    16.6 +#include "mesh.h"
    16.7 +#include "meshgen.h"
    16.8 +#include "texture.h"
    16.9 +#include "shader.h"
   16.10 +#include "sdrman.h"
   16.11 +#include "opengl.h"
   16.12 +#include "logger.h"
   16.13 +
   16.14 +void draw_rect(const Vector3 &v1, const Vector3 &v2, Texture2D *tex, ShaderProg *sdr)
   16.15 +{
   16.16 +	static ShaderProg *defsdr;
   16.17 +
   16.18 +	if(!defsdr) {
   16.19 +		if(!(defsdr = get_sdrprog("defpost.v.glsl", "defpost.p.glsl"))) {
   16.20 +			static bool didlog;
   16.21 +			if(!didlog) {
   16.22 +				error_log("draw_rect: failed to load default shader\n");
   16.23 +				didlog = true;
   16.24 +			}
   16.25 +			if(!sdr) {
   16.26 +				return;
   16.27 +			}
   16.28 +		}
   16.29 +	}
   16.30 +
   16.31 +
   16.32 +	if(tex) {
   16.33 +		set_texture(tex);
   16.34 +	}
   16.35 +	if(sdr) {
   16.36 +		sdr->bind();
   16.37 +	} else {
   16.38 +		defsdr->bind();
   16.39 +
   16.40 +		assert(defsdr->get_attrib_location("attr_vertex") == MESH_ATTR_VERTEX);
   16.41 +		assert(defsdr->get_attrib_location("attr_texcoord") == MESH_ATTR_TEXCOORD);
   16.42 +	}
   16.43 +
   16.44 +
   16.45 +	float varr[] = {
   16.46 +		v1.x, v1.y, v1.z, v2.x, v1.y, v2.z,
   16.47 +		v2.x, v2.y, v2.z, v1.x, v2.y, v1.z
   16.48 +	};
   16.49 +	static const float tarr[] = { 0, 0, 1, 0, 1, 1, 0, 1 };
   16.50 +	static const unsigned int idxarr[] = {0, 1, 2, 0, 2, 3};
   16.51 +
   16.52 +	// disable VBOs if they are enabled
   16.53 +	glBindBuffer(GL_ARRAY_BUFFER, 0);
   16.54 +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
   16.55 +
   16.56 +	glEnableVertexAttribArray(MESH_ATTR_VERTEX);
   16.57 +	glVertexAttribPointer(MESH_ATTR_VERTEX, 3, GL_FLOAT, GL_FALSE, 0, varr);
   16.58 +	glEnableVertexAttribArray(MESH_ATTR_TEXCOORD);
   16.59 +	glVertexAttribPointer(MESH_ATTR_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, tarr);
   16.60 +
   16.61 +	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, idxarr);
   16.62 +
   16.63 +	glDisableVertexAttribArray(MESH_ATTR_VERTEX);
   16.64 +	glDisableVertexAttribArray(MESH_ATTR_TEXCOORD);
   16.65 +
   16.66 +	set_texture(0);
   16.67 +}

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/src/gfxutil.h	Thu Nov 14 05:27:09 2013 +0200
    17.3 @@ -0,0 +1,11 @@
    17.4 +#ifndef GFXUTIL_H_
    17.5 +#define GFXUTIL_H_
    17.6 +
    17.7 +#include <vmath/vmath.h>
    17.8 +
    17.9 +class Texture2D;
   17.10 +class ShaderProg;
   17.11 +
   17.12 +void draw_rect(const Vector3 &v1, const Vector3 &v2, Texture2D *tex = 0, ShaderProg *sdr = 0);
   17.13 +
   17.14 +#endif	// GFXUTIL_H_

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/src/image.cc	Thu Nov 14 05:27:09 2013 +0200
    18.3 @@ -0,0 +1,192 @@
    18.4 +#include <string.h>
    18.5 +#include "imago2.h"
    18.6 +#include "image.h"
    18.7 +#include "logger.h"
    18.8 +
    18.9 +
   18.10 +static int pixel_elements(Image::Format fmt);
   18.11 +static int elem_size(Image::Format fmt);
   18.12 +static int pixel_size(Image::Format fmt);
   18.13 +
   18.14 +Image::Image()
   18.15 +{
   18.16 +	fmt = FMT_RGBA;
   18.17 +	width = height = 0;
   18.18 +	pixels = 0;
   18.19 +}
   18.20 +
   18.21 +Image::~Image()
   18.22 +{
   18.23 +	delete [] (char*)pixels;
   18.24 +}
   18.25 +
   18.26 +int Image::get_width() const
   18.27 +{
   18.28 +	return width;
   18.29 +}
   18.30 +
   18.31 +int Image::get_height() const
   18.32 +{
   18.33 +	return height;
   18.34 +}
   18.35 +
   18.36 +Image::Format Image::get_format() const
   18.37 +{
   18.38 +	return fmt;
   18.39 +}
   18.40 +
   18.41 +bool Image::create(int x, int y, Format fmt)
   18.42 +{
   18.43 +	width = x;
   18.44 +	height = y;
   18.45 +	this->fmt = fmt;
   18.46 +
   18.47 +	try {
   18.48 +		pixels = new char[x * y * pixel_size(fmt)];
   18.49 +	}
   18.50 +	catch(...) {
   18.51 +		return false;
   18.52 +	}
   18.53 +	return true;
   18.54 +}
   18.55 +
   18.56 +bool Image::set_pixels(int x, int y, void *pixels, Format fmt)
   18.57 +{
   18.58 +	if(!create(x, y, fmt)) {
   18.59 +		return false;
   18.60 +	}
   18.61 +	memcpy(this->pixels, pixels, x * y * pixel_size(fmt));
   18.62 +	return true;
   18.63 +}
   18.64 +
   18.65 +void *Image::get_pixels() const
   18.66 +{
   18.67 +	return pixels;
   18.68 +}
   18.69 +
   18.70 +bool Image::load(const char *fname)
   18.71 +{
   18.72 +	struct img_pixmap pixmap;
   18.73 +
   18.74 +	img_init(&pixmap);
   18.75 +	if(img_load(&pixmap, fname) == -1) {
   18.76 +		return false;
   18.77 +	}
   18.78 +
   18.79 +	Format fmt;
   18.80 +	switch(pixmap.fmt) {
   18.81 +	case IMG_FMT_GREY8:
   18.82 +		fmt = FMT_GREY;
   18.83 +		break;
   18.84 +	case IMG_FMT_RGB24:
   18.85 +		fmt = FMT_RGB;
   18.86 +		break;
   18.87 +	case IMG_FMT_RGBA32:
   18.88 +		fmt = FMT_RGBA;
   18.89 +		break;
   18.90 +	case IMG_FMT_GREYF:
   18.91 +		fmt = FMT_GREY_FLOAT;
   18.92 +		break;
   18.93 +	case IMG_FMT_RGBF:
   18.94 +		fmt = FMT_RGB_FLOAT;
   18.95 +		break;
   18.96 +	case IMG_FMT_RGBAF:
   18.97 +		fmt = FMT_RGBA_FLOAT;
   18.98 +		break;
   18.99 +	default:
  18.100 +		img_destroy(&pixmap);
  18.101 +		return false;
  18.102 +	}
  18.103 +
  18.104 +	if(!set_pixels(pixmap.width, pixmap.height, pixmap.pixels, fmt)) {
  18.105 +		img_destroy(&pixmap);
  18.106 +		return false;
  18.107 +	}
  18.108 +	img_destroy(&pixmap);
  18.109 +	return true;
  18.110 +}
  18.111 +
  18.112 +bool Image::save(const char *fname) const
  18.113 +{
  18.114 +	struct img_pixmap pixmap;
  18.115 +
  18.116 +	img_init(&pixmap);
  18.117 +
  18.118 +	switch(fmt) {
  18.119 +	case FMT_GREY:
  18.120 +		pixmap.fmt = IMG_FMT_GREY8;
  18.121 +		break;
  18.122 +	case FMT_GREY_FLOAT:
  18.123 +		pixmap.fmt = IMG_FMT_GREYF;
  18.124 +		break;
  18.125 +	case FMT_RGB:
  18.126 +		pixmap.fmt = IMG_FMT_RGB24;
  18.127 +		break;
  18.128 +	case FMT_RGB_FLOAT:
  18.129 +		pixmap.fmt = IMG_FMT_RGBF;
  18.130 +		break;
  18.131 +	case FMT_RGBA:
  18.132 +		pixmap.fmt = IMG_FMT_RGBA32;
  18.133 +		break;
  18.134 +	case FMT_RGBA_FLOAT:
  18.135 +		pixmap.fmt = IMG_FMT_RGBAF;
  18.136 +		break;
  18.137 +	default:
  18.138 +		return false;
  18.139 +	}
  18.140 +
  18.141 +	pixmap.width = width;
  18.142 +	pixmap.height = height;
  18.143 +	pixmap.pixels = pixels;
  18.144 +	pixmap.pixelsz = pixel_size(fmt);
  18.145 +
  18.146 +	if(img_save(&pixmap, fname) == -1) {
  18.147 +		return false;
  18.148 +	}
  18.149 +	return true;
  18.150 +}
  18.151 +
  18.152 +static int pixel_elements(Image::Format fmt)
  18.153 +{
  18.154 +	switch(fmt) {
  18.155 +	case Image::FMT_GREY:
  18.156 +	case Image::FMT_GREY_FLOAT:
  18.157 +		return 1;
  18.158 +
  18.159 +	case Image::FMT_RGB:
  18.160 +	case Image::FMT_RGB_FLOAT:
  18.161 +		return 3;
  18.162 +
  18.163 +	case Image::FMT_RGBA:
  18.164 +	case Image::FMT_RGBA_FLOAT:
  18.165 +		return 4;
  18.166 +
  18.167 +	default:
  18.168 +		break;
  18.169 +	}
  18.170 +	return 0;
  18.171 +}
  18.172 +
  18.173 +static int elem_size(Image::Format fmt)
  18.174 +{
  18.175 +	switch(fmt) {
  18.176 +	case Image::FMT_GREY:
  18.177 +	case Image::FMT_RGB:
  18.178 +	case Image::FMT_RGBA:
  18.179 +		return 1;
  18.180 +
  18.181 +	case Image::FMT_GREY_FLOAT:
  18.182 +	case Image::FMT_RGB_FLOAT:
  18.183 +	case Image::FMT_RGBA_FLOAT:
  18.184 +		return sizeof(float);
  18.185 +
  18.186 +	default:
  18.187 +		break;
  18.188 +	}
  18.189 +	return 0;
  18.190 +}
  18.191 +
  18.192 +static int pixel_size(Image::Format fmt)
  18.193 +{
  18.194 +	return elem_size(fmt) * pixel_elements(fmt);
  18.195 +}

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/src/image.h	Thu Nov 14 05:27:09 2013 +0200
    19.3 @@ -0,0 +1,38 @@
    19.4 +#ifndef IMAGE_H_
    19.5 +#define IMAGE_H_
    19.6 +
    19.7 +
    19.8 +class Image {
    19.9 +public:
   19.10 +	enum Format {
   19.11 +		FMT_GREY,
   19.12 +		FMT_RGB,
   19.13 +		FMT_RGBA,
   19.14 +		FMT_GREY_FLOAT,
   19.15 +		FMT_RGB_FLOAT,
   19.16 +		FMT_RGBA_FLOAT
   19.17 +	};
   19.18 +
   19.19 +private:
   19.20 +	Format fmt;
   19.21 +	int width, height;
   19.22 +	void *pixels;
   19.23 +
   19.24 +public:
   19.25 +	Image();
   19.26 +	~Image();
   19.27 +
   19.28 +	int get_width() const;
   19.29 +	int get_height() const;
   19.30 +
   19.31 +	Format get_format() const;
   19.32 +
   19.33 +	bool create(int x, int y, Format fmt = FMT_RGBA);
   19.34 +	bool set_pixels(int x, int y, void *pixels, Format fmt = FMT_RGBA);
   19.35 +	void *get_pixels() const;
   19.36 +
   19.37 +	bool load(const char *fname);
   19.38 +	bool save(const char *fname) const;
   19.39 +};
   19.40 +
   19.41 +#endif	// IMAGE_H_

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/src/logger.cc	Thu Nov 14 05:27:09 2013 +0200
    20.3 @@ -0,0 +1,96 @@
    20.4 +#include <stdio.h>
    20.5 +#include <stdarg.h>
    20.6 +#include "logger.h"
    20.7 +
    20.8 +#if defined(unix) || defined(__unix__) || defined(__APPLE__)
    20.9 +#include <unistd.h>
   20.10 +#endif
   20.11 +
   20.12 +enum { LOG_INFO, LOG_WARNING, LOG_ERROR, LOG_DEBUG };
   20.13 +
   20.14 +static int typecolor(int type);
   20.15 +
   20.16 +static FILE *fp = stdout;
   20.17 +
   20.18 +static void logmsg(int type, const char *fmt, va_list ap)
   20.19 +{
   20.20 +#if defined(unix) || defined(__unix__) || (defined(__APPLE__) && !defined(TARGET_IPHONE))
   20.21 +	if(isatty(fileno(fp)) && type != LOG_INFO) {
   20.22 +		int c = typecolor(type);
   20.23 +		fprintf(fp, "\033[%dm", c);
   20.24 +		vfprintf(fp, fmt, ap);
   20.25 +		fprintf(fp, "\033[0m");
   20.26 +	} else
   20.27 +#endif
   20.28 +	{
   20.29 +		vfprintf(fp, fmt, ap);
   20.30 +	}
   20.31 +	if(type == LOG_ERROR || type == LOG_DEBUG) {
   20.32 +		fflush(fp);
   20.33 +	}
   20.34 +}
   20.35 +
   20.36 +void info_log(const char *fmt, ...)
   20.37 +{
   20.38 +	va_list ap;
   20.39 +
   20.40 +	va_start(ap, fmt);
   20.41 +	logmsg(LOG_INFO, fmt, ap);
   20.42 +	va_end(ap);
   20.43 +}
   20.44 +
   20.45 +void warning_log(const char *fmt, ...)
   20.46 +{
   20.47 +	va_list ap;
   20.48 +
   20.49 +	va_start(ap, fmt);
   20.50 +	logmsg(LOG_WARNING, fmt, ap);
   20.51 +	va_end(ap);
   20.52 +}
   20.53 +
   20.54 +void error_log(const char *fmt, ...)
   20.55 +{
   20.56 +	va_list ap;
   20.57 +
   20.58 +	va_start(ap, fmt);
   20.59 +	logmsg(LOG_ERROR, fmt, ap);
   20.60 +	va_end(ap);
   20.61 +}
   20.62 +
   20.63 +void debug_log(const char *fmt, ...)
   20.64 +{
   20.65 +	va_list ap;
   20.66 +
   20.67 +	va_start(ap, fmt);
   20.68 +	logmsg(LOG_DEBUG, fmt, ap);
   20.69 +	va_end(ap);
   20.70 +}
   20.71 +
   20.72 +enum {
   20.73 +	BLACK = 0,
   20.74 +	RED,
   20.75 +	GREEN,
   20.76 +	YELLOW,
   20.77 +	BLUE,
   20.78 +	MAGENTA,
   20.79 +	CYAN,
   20.80 +	WHITE
   20.81 +};
   20.82 +
   20.83 +#define ANSI_FGCOLOR(x)	(30 + (x))
   20.84 +#define ANSI_BGCOLOR(x)	(40 + (x))
   20.85 +
   20.86 +static int typecolor(int type)
   20.87 +{
   20.88 +	switch(type) {
   20.89 +	case LOG_ERROR:
   20.90 +		return ANSI_FGCOLOR(RED);
   20.91 +	case LOG_WARNING:
   20.92 +		return ANSI_FGCOLOR(YELLOW);
   20.93 +	case LOG_DEBUG:
   20.94 +		return ANSI_FGCOLOR(MAGENTA);
   20.95 +	default:
   20.96 +		break;
   20.97 +	}
   20.98 +	return 37;
   20.99 +}

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/src/logger.h	Thu Nov 14 05:27:09 2013 +0200
    21.3 @@ -0,0 +1,9 @@
    21.4 +#ifndef LOGGER_H_
    21.5 +#define LOGGER_H_
    21.6 +
    21.7 +void info_log(const char *fmt, ...);
    21.8 +void warning_log(const char *fmt, ...);
    21.9 +void error_log(const char *fmt, ...);
   21.10 +void debug_log(const char *fmt, ...);
   21.11 +
   21.12 +#endif	// LOGGER_H_

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/src/material.cc	Thu Nov 14 05:27:09 2013 +0200
    22.3 @@ -0,0 +1,65 @@
    22.4 +#include "material.h"
    22.5 +#include "unistate.h"
    22.6 +
    22.7 +Material::Material()
    22.8 +	: diffuse(1, 1, 1), specular(0, 0, 0)
    22.9 +{
   22.10 +	alpha = 1.0;
   22.11 +	shininess = 1.0;
   22.12 +
   22.13 +	for(int i=0; i<MAX_MTL_TEXTURES; i++) {
   22.14 +		tex[i] = 0;
   22.15 +	}
   22.16 +}
   22.17 +
   22.18 +
   22.19 +void Material::setup(bool use_textures) const
   22.20 +{
   22.21 +	static bool done_init;
   22.22 +	static int st_diffuse_idx, st_specular_idx, st_shininess_idx, st_alpha_idx;
   22.23 +	static int st_tex_diffuse_idx, st_tex_specular_idx, st_tex_normal_idx;
   22.24 +	static int st_tex_idx[MAX_MTL_TEXTURES];
   22.25 +
   22.26 +	if(!done_init) {
   22.27 +		st_diffuse_idx = add_unistate("st_mtl_diffuse", ST_FLOAT3);
   22.28 +		st_specular_idx = add_unistate("st_mtl_specular", ST_FLOAT3);
   22.29 +		st_shininess_idx = add_unistate("st_mtl_shininess", ST_FLOAT);
   22.30 +		st_alpha_idx = add_unistate("st_mtl_alpha", ST_FLOAT);
   22.31 +		st_tex_diffuse_idx = add_unistate("st_tex_diffuse", ST_INT);
   22.32 +		st_tex_specular_idx = add_unistate("st_tex_specular", ST_INT);
   22.33 +		st_tex_normal_idx = add_unistate("st_tex_normal", ST_INT);
   22.34 +
   22.35 +		for(int i=0; i<MAX_MTL_TEXTURES; i++) {
   22.36 +			char name[32];
   22.37 +			sprintf(name, "st_tex%d", i);
   22.38 +			st_tex_idx[i] = add_unistate(name, ST_INT);
   22.39 +		}
   22.40 +		done_init = true;
   22.41 +	}
   22.42 +
   22.43 +	set_unistate(st_diffuse_idx, diffuse);
   22.44 +	set_unistate(st_specular_idx, specular);
   22.45 +	set_unistate(st_shininess_idx, shininess);
   22.46 +	set_unistate(st_alpha_idx, alpha);
   22.47 +
   22.48 +	if(!use_textures) {
   22.49 +		return;	// we're done
   22.50 +	}
   22.51 +
   22.52 +	const int tex_named_idx[] = {
   22.53 +		st_tex_diffuse_idx, st_tex_specular_idx, st_tex_normal_idx, -1
   22.54 +	};
   22.55 +
   22.56 +	int tex_unit = 0;
   22.57 +	for(int i=0; i<MAX_MTL_TEXTURES; i++) {
   22.58 +		if(tex[i]) {
   22.59 +			tex[i]->bind(tex_unit);
   22.60 +
   22.61 +			if(tex_named_idx[i]) {
   22.62 +				set_unistate(tex_named_idx[i], tex_unit);
   22.63 +			}
   22.64 +			set_unistate(st_tex_idx[i], tex_unit);
   22.65 +			tex_unit++;
   22.66 +		}
   22.67 +	}
   22.68 +}

    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/src/material.h	Thu Nov 14 05:27:09 2013 +0200
    23.3 @@ -0,0 +1,29 @@
    23.4 +#ifndef MATERIAL_H_
    23.5 +#define MATERIAL_H_
    23.6 +
    23.7 +#include "vmath/vmath.h"
    23.8 +#include "texture.h"
    23.9 +
   23.10 +enum {
   23.11 +	TEX_DIFFUSE,
   23.12 +	TEX_SPECULAR,
   23.13 +	TEX_NORMAL,
   23.14 +	TEX_MISC,
   23.15 +
   23.16 +	MAX_MTL_TEXTURES
   23.17 +};
   23.18 +
   23.19 +class Material {
   23.20 +public:
   23.21 +	Vector3 diffuse, specular;
   23.22 +	float alpha;
   23.23 +	float shininess;
   23.24 +
   23.25 +	Texture *tex[MAX_MTL_TEXTURES];
   23.26 +
   23.27 +	Material();
   23.28 +
   23.29 +	void setup(bool use_textures = true) const;
   23.30 +};
   23.31 +
   23.32 +#endif	// MATERIAL_H_

    24.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.2 +++ b/src/mesh.cc	Thu Nov 14 05:27:09 2013 +0200
    24.3 @@ -0,0 +1,971 @@
    24.4 +#include <stdio.h>
    24.5 +#include <stdlib.h>
    24.6 +#include <float.h>
    24.7 +#include <assert.h>
    24.8 +#include "opengl.h"
    24.9 +#include "mesh.h"
   24.10 +#include "xform_node.h"
   24.11 +#include "logger.h"
   24.12 +
   24.13 +int Mesh::global_sdr_loc[NUM_MESH_ATTR] = { 0, 1, 2, 3, 4, 5 };
   24.14 +unsigned int Mesh::intersect_mode = ISECT_DEFAULT;
   24.15 +float Mesh::vertex_sel_dist = 0.01;
   24.16 +float Mesh::vis_vecsize = 1.0;
   24.17 +
   24.18 +Mesh::Mesh()
   24.19 +{
   24.20 +	clear();
   24.21 +
   24.22 +	glGenBuffers(NUM_MESH_ATTR + 1, buffer_objects);
   24.23 +
   24.24 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
   24.25 +		vattr[i].vbo = buffer_objects[i];
   24.26 +	}
   24.27 +	ibo = buffer_objects[NUM_MESH_ATTR];
   24.28 +	wire_ibo = 0;
   24.29 +}
   24.30 +
   24.31 +Mesh::~Mesh()
   24.32 +{
   24.33 +	glDeleteBuffers(NUM_MESH_ATTR + 1, buffer_objects);
   24.34 +
   24.35 +	if(wire_ibo) {
   24.36 +		glDeleteBuffers(1, &wire_ibo);
   24.37 +	}
   24.38 +}
   24.39 +
   24.40 +void Mesh::set_name(const char *name)
   24.41 +{
   24.42 +	this->name = name;
   24.43 +}
   24.44 +
   24.45 +const char *Mesh::get_name() const
   24.46 +{
   24.47 +	return name.c_str();
   24.48 +}
   24.49 +
   24.50 +bool Mesh::has_attrib(int attr) const
   24.51 +{
   24.52 +	if(attr < 0 || attr >= NUM_MESH_ATTR) {
   24.53 +		return false;
   24.54 +	}
   24.55 +
   24.56 +	// if neither of these is valid, then nobody has set this attribute
   24.57 +	return vattr[attr].vbo_valid || vattr[attr].data_valid;
   24.58 +}
   24.59 +
   24.60 +void Mesh::clear()
   24.61 +{
   24.62 +	bones.clear();
   24.63 +
   24.64 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
   24.65 +		vattr[i].nelem = 0;
   24.66 +		vattr[i].vbo_valid = false;
   24.67 +		vattr[i].data_valid = false;
   24.68 +		//vattr[i].sdr_loc = -1;
   24.69 +		vattr[i].data.clear();
   24.70 +	}
   24.71 +	ibo_valid = false;
   24.72 +	idata.clear();
   24.73 +
   24.74 +	wire_ibo_valid = false;
   24.75 +
   24.76 +	nverts = nfaces = 0;
   24.77 +
   24.78 +	bsph_valid = false;
   24.79 +	aabb_valid = false;
   24.80 +}
   24.81 +
   24.82 +float *Mesh::set_attrib_data(int attrib, int nelem, unsigned int num, const float *data)
   24.83 +{
   24.84 +	if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
   24.85 +		error_log("%s: invalid attrib: %d\n", __FUNCTION__, attrib);
   24.86 +		return 0;
   24.87 +	}
   24.88 +
   24.89 +	if(nverts && num != nverts) {
   24.90 +		error_log("%s: attribute count missmatch (%d instead of %d)\n", __FUNCTION__, num, nverts);
   24.91 +		return 0;
   24.92 +	}
   24.93 +	nverts = num;
   24.94 +
   24.95 +	vattr[attrib].data.clear();
   24.96 +	vattr[attrib].nelem = nelem;
   24.97 +	vattr[attrib].data.resize(num * nelem);
   24.98 +
   24.99 +	if(data) {
  24.100 +		memcpy(&vattr[attrib].data[0], data, num * nelem * sizeof *data);
  24.101 +	}
  24.102 +
  24.103 +	vattr[attrib].data_valid = true;
  24.104 +	vattr[attrib].vbo_valid = false;
  24.105 +	return &vattr[attrib].data[0];
  24.106 +}
  24.107 +
  24.108 +float *Mesh::get_attrib_data(int attrib)
  24.109 +{
  24.110 +	if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
  24.111 +		error_log("%s: invalid attrib: %d\n", __FUNCTION__, attrib);
  24.112 +		return 0;
  24.113 +	}
  24.114 +
  24.115 +	vattr[attrib].vbo_valid = false;
  24.116 +	return (float*)((const Mesh*)this)->get_attrib_data(attrib);
  24.117 +}
  24.118 +
  24.119 +const float *Mesh::get_attrib_data(int attrib) const
  24.120 +{
  24.121 +	if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
  24.122 +		error_log("%s: invalid attrib: %d\n", __FUNCTION__, attrib);
  24.123 +		return 0;
  24.124 +	}
  24.125 +
  24.126 +	if(!vattr[attrib].data_valid) {
  24.127 +#if GL_ES_VERSION_2_0
  24.128 +		error_log("%s: can't read back attrib data on CrippledGL ES\n", __FUNCTION__);
  24.129 +		return 0;
  24.130 +#else
  24.131 +		if(!vattr[attrib].vbo_valid) {
  24.132 +			error_log("%s: unavailable attrib: %d\n", __FUNCTION__, attrib);
  24.133 +			return 0;
  24.134 +		}
  24.135 +
  24.136 +		// local data copy is unavailable, grab the data from the vbo
  24.137 +		Mesh *m = (Mesh*)this;
  24.138 +		m->vattr[attrib].data.resize(nverts * vattr[attrib].nelem);
  24.139 +
  24.140 +		glBindBuffer(GL_ARRAY_BUFFER, vattr[attrib].vbo);
  24.141 +		void *data = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
  24.142 +		memcpy(&m->vattr[attrib].data[0], data, nverts * vattr[attrib].nelem * sizeof(float));
  24.143 +		glUnmapBuffer(GL_ARRAY_BUFFER);
  24.144 +
  24.145 +		vattr[attrib].data_valid = true;
  24.146 +#endif
  24.147 +	}
  24.148 +
  24.149 +	return &vattr[attrib].data[0];
  24.150 +}
  24.151 +
  24.152 +void Mesh::set_attrib(int attrib, int idx, const Vector4 &v)
  24.153 +{
  24.154 +	float *data = get_attrib_data(attrib);
  24.155 +	if(data) {
  24.156 +		data += idx * vattr[attrib].nelem;
  24.157 +		for(int i=0; i<vattr[attrib].nelem; i++) {
  24.158 +			data[i] = v[i];
  24.159 +		}
  24.160 +	}
  24.161 +}
  24.162 +
  24.163 +Vector4 Mesh::get_attrib(int attrib, int idx) const
  24.164 +{
  24.165 +	Vector4 v(0.0, 0.0, 0.0, 1.0);
  24.166 +	const float *data = get_attrib_data(attrib);
  24.167 +	if(data) {
  24.168 +		data += idx * vattr[attrib].nelem;
  24.169 +		for(int i=0; i<vattr[attrib].nelem; i++) {
  24.170 +			v[i] = data[i];
  24.171 +		}
  24.172 +	}
  24.173 +	return v;
  24.174 +}
  24.175 +
  24.176 +unsigned int *Mesh::set_index_data(int num, const unsigned int *indices)
  24.177 +{
  24.178 +	int nidx = nfaces * 3;
  24.179 +	if(nidx && num != nidx) {
  24.180 +		error_log("%s: index count missmatch (%d instead of %d)\n", __FUNCTION__, num, nidx);
  24.181 +		return 0;
  24.182 +	}
  24.183 +	nfaces = num / 3;
  24.184 +
  24.185 +	idata.clear();
  24.186 +	idata.resize(num);
  24.187 +
  24.188 +	if(indices) {
  24.189 +		memcpy(&idata[0], indices, num * sizeof *indices);
  24.190 +	}
  24.191 +
  24.192 +	idata_valid = true;
  24.193 +	ibo_valid = false;
  24.194 +
  24.195 +	return &idata[0];
  24.196 +}
  24.197 +
  24.198 +unsigned int *Mesh::get_index_data()
  24.199 +{
  24.200 +	ibo_valid = false;
  24.201 +	return (unsigned int*)((const Mesh*)this)->get_index_data();
  24.202 +}
  24.203 +
  24.204 +const unsigned int *Mesh::get_index_data() const
  24.205 +{
  24.206 +	if(!idata_valid) {
  24.207 +#if GL_ES_VERSION_2_0
  24.208 +		error_log("%s: can't read back index data in CrippledGL ES\n", __FUNCTION__);
  24.209 +		return 0;
  24.210 +#else
  24.211 +		if(!ibo_valid) {
  24.212 +			error_log("%s: indices unavailable\n", __FUNCTION__);
  24.213 +			return 0;
  24.214 +		}
  24.215 +
  24.216 +		// local data copy is unavailable, gram the data from the ibo
  24.217 +		Mesh *m = (Mesh*)this;
  24.218 +		int nidx = nfaces * 3;
  24.219 +		m->idata.resize(nidx);
  24.220 +
  24.221 +		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
  24.222 +		void *data = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
  24.223 +		memcpy(&m->idata[0], data, nidx * sizeof(unsigned int));
  24.224 +		glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
  24.225 +
  24.226 +		idata_valid = true;
  24.227 +#endif
  24.228 +	}
  24.229 +
  24.230 +	return &idata[0];
  24.231 +}
  24.232 +
  24.233 +void Mesh::append(const Mesh &mesh)
  24.234 +{
  24.235 +	unsigned int idxoffs = nverts;
  24.236 +
  24.237 +	nverts += mesh.nverts;
  24.238 +	nfaces += mesh.nfaces;
  24.239 +
  24.240 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.241 +		if(has_attrib(i) && mesh.has_attrib(i)) {
  24.242 +			// force validating the data arrays
  24.243 +			get_attrib_data(i);
  24.244 +			mesh.get_attrib_data(i);
  24.245 +
  24.246 +			// append the mesh data
  24.247 +			vattr[i].data.insert(vattr[i].data.end(), mesh.vattr[i].data.begin(), mesh.vattr[i].data.end());
  24.248 +		}
  24.249 +	}
  24.250 +
  24.251 +	if(ibo_valid || idata_valid) {
  24.252 +		// make index arrays valid
  24.253 +		get_index_data();
  24.254 +		mesh.get_index_data();
  24.255 +
  24.256 +		size_t orig_sz = idata.size();
  24.257 +
  24.258 +		idata.insert(idata.end(), mesh.idata.begin(), mesh.idata.end());
  24.259 +
  24.260 +		// fixup all the new indices
  24.261 +		for(size_t i=orig_sz; i<idata.size(); i++) {
  24.262 +			idata[i] += idxoffs;
  24.263 +		}
  24.264 +	}
  24.265 +
  24.266 +	// fuck everything
  24.267 +	wire_ibo_valid = false;
  24.268 +	aabb_valid = false;
  24.269 +	bsph_valid = false;
  24.270 +}
  24.271 +
  24.272 +// assemble a complete vertex by adding all the useful attributes
  24.273 +void Mesh::vertex(float x, float y, float z)
  24.274 +{
  24.275 +	cur_val[MESH_ATTR_VERTEX] = Vector4(x, y, z, 1.0f);
  24.276 +	vattr[MESH_ATTR_VERTEX].data_valid = true;
  24.277 +	vattr[MESH_ATTR_VERTEX].nelem = 3;
  24.278 +
  24.279 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.280 +		if(vattr[i].data_valid) {
  24.281 +			for(int j=0; j<vattr[MESH_ATTR_VERTEX].nelem; j++) {
  24.282 +				vattr[i].data.push_back(cur_val[i][j]);
  24.283 +			}
  24.284 +		}
  24.285 +		vattr[i].vbo_valid = false;
  24.286 +	}
  24.287 +
  24.288 +	if(idata_valid) {
  24.289 +		idata.clear();
  24.290 +	}
  24.291 +	ibo_valid = idata_valid = false;
  24.292 +}
  24.293 +
  24.294 +void Mesh::normal(float nx, float ny, float nz)
  24.295 +{
  24.296 +	cur_val[MESH_ATTR_NORMAL] = Vector4(nx, ny, nz, 1.0f);
  24.297 +	vattr[MESH_ATTR_NORMAL].data_valid = true;
  24.298 +	vattr[MESH_ATTR_NORMAL].nelem = 3;
  24.299 +}
  24.300 +
  24.301 +void Mesh::tangent(float tx, float ty, float tz)
  24.302 +{
  24.303 +	cur_val[MESH_ATTR_TANGENT] = Vector4(tx, ty, tz, 1.0f);
  24.304 +	vattr[MESH_ATTR_TANGENT].data_valid = true;
  24.305 +	vattr[MESH_ATTR_TANGENT].nelem = 3;
  24.306 +}
  24.307 +
  24.308 +void Mesh::texcoord(float u, float v, float w)
  24.309 +{
  24.310 +	cur_val[MESH_ATTR_TEXCOORD] = Vector4(u, v, w, 1.0f);
  24.311 +	vattr[MESH_ATTR_TEXCOORD].data_valid = true;
  24.312 +	vattr[MESH_ATTR_TEXCOORD].nelem = 3;
  24.313 +}
  24.314 +
  24.315 +void Mesh::boneweights(float w1, float w2, float w3, float w4)
  24.316 +{
  24.317 +	cur_val[MESH_ATTR_BONEWEIGHTS] = Vector4(w1, w2, w3, w4);
  24.318 +	vattr[MESH_ATTR_BONEWEIGHTS].data_valid = true;
  24.319 +	vattr[MESH_ATTR_BONEWEIGHTS].nelem = 4;
  24.320 +}
  24.321 +
  24.322 +void Mesh::boneidx(int idx1, int idx2, int idx3, int idx4)
  24.323 +{
  24.324 +	cur_val[MESH_ATTR_BONEIDX] = Vector4(idx1, idx2, idx3, idx4);
  24.325 +	vattr[MESH_ATTR_BONEIDX].data_valid = true;
  24.326 +	vattr[MESH_ATTR_BONEIDX].nelem = 4;
  24.327 +}
  24.328 +
  24.329 +/// static function
  24.330 +void Mesh::set_attrib_location(int attr, int loc)
  24.331 +{
  24.332 +	if(attr < 0 || attr >= NUM_MESH_ATTR) {
  24.333 +		return;
  24.334 +	}
  24.335 +	Mesh::global_sdr_loc[attr] = loc;
  24.336 +}
  24.337 +
  24.338 +/// static function
  24.339 +int Mesh::get_attrib_location(int attr)
  24.340 +{
  24.341 +	if(attr < 0 || attr >= NUM_MESH_ATTR) {
  24.342 +		return -1;
  24.343 +	}
  24.344 +	return Mesh::global_sdr_loc[attr];
  24.345 +}
  24.346 +
  24.347 +/// static function
  24.348 +void Mesh::clear_attrib_locations()
  24.349 +{
  24.350 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.351 +		Mesh::global_sdr_loc[i] = -1;
  24.352 +	}
  24.353 +}
  24.354 +
  24.355 +/// static function
  24.356 +void Mesh::set_vis_vecsize(float sz)
  24.357 +{
  24.358 +	Mesh::vis_vecsize = sz;
  24.359 +}
  24.360 +
  24.361 +float Mesh::get_vis_vecsize()
  24.362 +{
  24.363 +	return Mesh::vis_vecsize;
  24.364 +}
  24.365 +
  24.366 +void Mesh::apply_xform(const Matrix4x4 &xform)
  24.367 +{
  24.368 +	Matrix4x4 dir_xform = xform;
  24.369 +	dir_xform[0][3] = dir_xform[1][3] = dir_xform[2][3] = 0.0f;
  24.370 +	dir_xform[3][0] = dir_xform[3][1] = dir_xform[3][2] = 0.0f;
  24.371 +	dir_xform[3][3] = 1.0f;
  24.372 +
  24.373 +	apply_xform(xform, dir_xform);
  24.374 +}
  24.375 +
  24.376 +void Mesh::apply_xform(const Matrix4x4 &xform, const Matrix4x4 &dir_xform)
  24.377 +{
  24.378 +	for(unsigned int i=0; i<nverts; i++) {
  24.379 +		Vector4 v = get_attrib(MESH_ATTR_VERTEX, i);
  24.380 +		set_attrib(MESH_ATTR_VERTEX, i, v.transformed(xform));
  24.381 +
  24.382 +		if(has_attrib(MESH_ATTR_NORMAL)) {
  24.383 +			Vector3 n = get_attrib(MESH_ATTR_NORMAL, i);
  24.384 +			set_attrib(MESH_ATTR_NORMAL, i, n.transformed(dir_xform));
  24.385 +		}
  24.386 +		if(has_attrib(MESH_ATTR_TANGENT)) {
  24.387 +			Vector3 t = get_attrib(MESH_ATTR_TANGENT, i);
  24.388 +			set_attrib(MESH_ATTR_TANGENT, i, t.transformed(dir_xform));
  24.389 +		}
  24.390 +	}
  24.391 +}
  24.392 +
  24.393 +int Mesh::add_bone(XFormNode *bone)
  24.394 +{
  24.395 +	int idx = bones.size();
  24.396 +	bones.push_back(bone);
  24.397 +	return idx;
  24.398 +}
  24.399 +
  24.400 +const XFormNode *Mesh::get_bone(int idx) const
  24.401 +{
  24.402 +	if(idx < 0 || idx >= (int)bones.size()) {
  24.403 +		return 0;
  24.404 +	}
  24.405 +	return bones[idx];
  24.406 +}
  24.407 +
  24.408 +int Mesh::get_bones_count() const
  24.409 +{
  24.410 +	return (int)bones.size();
  24.411 +}
  24.412 +
  24.413 +void Mesh::draw() const
  24.414 +{
  24.415 +	((Mesh*)this)->update_buffers();
  24.416 +
  24.417 +	if(!vattr[MESH_ATTR_VERTEX].vbo_valid) {
  24.418 +		error_log("%s: invalid vertex buffer\n", __FUNCTION__);
  24.419 +		return;
  24.420 +	}
  24.421 +	if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
  24.422 +		error_log("%s: shader attribute location for vertices unset\n", __FUNCTION__);
  24.423 +		return;
  24.424 +	}
  24.425 +
  24.426 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.427 +		int loc = global_sdr_loc[i];
  24.428 +		if(loc >= 0 && vattr[i].vbo_valid) {
  24.429 +			glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
  24.430 +			glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
  24.431 +			glEnableVertexAttribArray(loc);
  24.432 +		}
  24.433 +	}
  24.434 +	glBindBuffer(GL_ARRAY_BUFFER, 0);
  24.435 +
  24.436 +	if(ibo_valid) {
  24.437 +		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
  24.438 +		glDrawElements(GL_TRIANGLES, nfaces * 3, GL_UNSIGNED_INT, 0);
  24.439 +		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  24.440 +	} else {
  24.441 +		glDrawArrays(GL_TRIANGLES, 0, nverts);
  24.442 +	}
  24.443 +
  24.444 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.445 +		int loc = global_sdr_loc[i];
  24.446 +		if(loc >= 0 && vattr[i].vbo_valid) {
  24.447 +			glDisableVertexAttribArray(loc);
  24.448 +		}
  24.449 +	}
  24.450 +}
  24.451 +
  24.452 +void Mesh::draw_wire() const
  24.453 +{
  24.454 +	((Mesh*)this)->update_wire_ibo();
  24.455 +
  24.456 +	if(!vattr[MESH_ATTR_VERTEX].vbo_valid || !wire_ibo_valid) {
  24.457 +		error_log("%s: invalid vertex buffer\n", __FUNCTION__);
  24.458 +		return;
  24.459 +	}
  24.460 +	if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
  24.461 +		error_log("%s: shader attribute location for vertices unset\n", __FUNCTION__);
  24.462 +		return;
  24.463 +	}
  24.464 +
  24.465 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.466 +		int loc = global_sdr_loc[i];
  24.467 +		if(loc >= 0 && vattr[i].vbo_valid) {
  24.468 +			glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
  24.469 +			glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
  24.470 +			glEnableVertexAttribArray(loc);
  24.471 +		}
  24.472 +	}
  24.473 +	glBindBuffer(GL_ARRAY_BUFFER, 0);
  24.474 +
  24.475 +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);
  24.476 +	glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
  24.477 +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  24.478 +
  24.479 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.480 +		int loc = global_sdr_loc[i];
  24.481 +		if(loc >= 0 && vattr[i].vbo_valid) {
  24.482 +			glDisableVertexAttribArray(loc);
  24.483 +		}
  24.484 +	}
  24.485 +}
  24.486 +
  24.487 +void Mesh::draw_vertices() const
  24.488 +{
  24.489 +	((Mesh*)this)->update_buffers();
  24.490 +
  24.491 +	if(!vattr[MESH_ATTR_VERTEX].vbo_valid) {
  24.492 +		error_log("%s: invalid vertex buffer\n", __FUNCTION__);
  24.493 +		return;
  24.494 +	}
  24.495 +	if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
  24.496 +		error_log("%s: shader attribute location for vertices unset\n", __FUNCTION__);
  24.497 +		return;
  24.498 +	}
  24.499 +
  24.500 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.501 +		int loc = global_sdr_loc[i];
  24.502 +		if(loc >= 0 && vattr[i].vbo_valid) {
  24.503 +			glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
  24.504 +			glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
  24.505 +			glEnableVertexAttribArray(loc);
  24.506 +		}
  24.507 +	}
  24.508 +	glBindBuffer(GL_ARRAY_BUFFER, 0);
  24.509 +
  24.510 +	glDrawArrays(GL_POINTS, 0, nverts);
  24.511 +
  24.512 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.513 +		int loc = global_sdr_loc[i];
  24.514 +		if(loc >= 0 && vattr[i].vbo_valid) {
  24.515 +			glDisableVertexAttribArray(loc);
  24.516 +		}
  24.517 +	}
  24.518 +}
  24.519 +
  24.520 +void Mesh::draw_normals() const
  24.521 +{
  24.522 +#ifdef USE_OLDGL
  24.523 +	int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];
  24.524 +	Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
  24.525 +	Vector3 *norm = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);
  24.526 +
  24.527 +	if(!varr || !norm || vert_loc < 0) {
  24.528 +		return;
  24.529 +	}
  24.530 +
  24.531 +	glBegin(GL_LINES);
  24.532 +	for(size_t i=0; i<nverts; i++) {
  24.533 +		glVertexAttrib3f(vert_loc, varr[i].x, varr[i].y, varr[i].z);
  24.534 +		Vector3 end = varr[i] + norm[i] * vis_vecsize;
  24.535 +		glVertexAttrib3f(vert_loc, end.x, end.y, end.z);
  24.536 +	}
  24.537 +	glEnd();
  24.538 +
  24.539 +#endif	// USE_OLDGL
  24.540 +}
  24.541 +
  24.542 +void Mesh::draw_tangents() const
  24.543 +{
  24.544 +#ifdef USE_OLDGL
  24.545 +	int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];
  24.546 +	Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
  24.547 +	Vector3 *tang = (Vector3*)get_attrib_data(MESH_ATTR_TANGENT);
  24.548 +
  24.549 +	if(!varr || !tang || vert_loc < 0) {
  24.550 +		return;
  24.551 +	}
  24.552 +
  24.553 +	glBegin(GL_LINES);
  24.554 +	for(size_t i=0; i<nverts; i++) {
  24.555 +		glVertexAttrib3f(vert_loc, varr[i].x, varr[i].y, varr[i].z);
  24.556 +		Vector3 end = varr[i] + tang[i] * vis_vecsize;
  24.557 +		glVertexAttrib3f(vert_loc, end.x, end.y, end.z);
  24.558 +	}
  24.559 +	glEnd();
  24.560 +
  24.561 +#endif	// USE_OLDGL
  24.562 +}
  24.563 +
  24.564 +void Mesh::get_aabbox(Vector3 *vmin, Vector3 *vmax) const
  24.565 +{
  24.566 +	if(!aabb_valid) {
  24.567 +		((Mesh*)this)->calc_aabb();
  24.568 +	}
  24.569 +	*vmin = aabb.min;
  24.570 +	*vmax = aabb.max;
  24.571 +}
  24.572 +
  24.573 +const AABox &Mesh::get_aabbox() const
  24.574 +{
  24.575 +	if(!aabb_valid) {
  24.576 +		((Mesh*)this)->calc_aabb();
  24.577 +	}
  24.578 +	return aabb;
  24.579 +}
  24.580 +
  24.581 +float Mesh::get_bsphere(Vector3 *center, float *rad) const
  24.582 +{
  24.583 +	if(!bsph_valid) {
  24.584 +		((Mesh*)this)->calc_bsph();
  24.585 +	}
  24.586 +	*center = bsph.center;
  24.587 +	*rad = bsph.radius;
  24.588 +	return bsph.radius;
  24.589 +}
  24.590 +
  24.591 +const Sphere &Mesh::get_bsphere() const
  24.592 +{
  24.593 +	if(!bsph_valid) {
  24.594 +		((Mesh*)this)->calc_bsph();
  24.595 +	}
  24.596 +	return bsph;
  24.597 +}
  24.598 +
  24.599 +/// static function
  24.600 +void Mesh::set_intersect_mode(unsigned int mode)
  24.601 +{
  24.602 +	Mesh::intersect_mode = mode;
  24.603 +}
  24.604 +
  24.605 +/// static function
  24.606 +unsigned int Mesh::get_intersect_mode()
  24.607 +{
  24.608 +	return Mesh::intersect_mode;
  24.609 +}
  24.610 +
  24.611 +/// static function
  24.612 +void Mesh::set_vertex_select_distance(float dist)
  24.613 +{
  24.614 +	Mesh::vertex_sel_dist = dist;
  24.615 +}
  24.616 +
  24.617 +/// static function
  24.618 +float Mesh::get_vertex_select_distance()
  24.619 +{
  24.620 +	return Mesh::vertex_sel_dist;
  24.621 +}
  24.622 +
  24.623 +bool Mesh::intersect(const Ray &ray, HitPoint *hit) const
  24.624 +{
  24.625 +	assert((Mesh::intersect_mode & (ISECT_VERTICES | ISECT_FACE)) != (ISECT_VERTICES | ISECT_FACE));
  24.626 +
  24.627 +	const Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
  24.628 +	const Vector3 *narr = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);
  24.629 +	if(!varr) {
  24.630 +		return false;
  24.631 +	}
  24.632 +	const unsigned int *idxarr = get_index_data();
  24.633 +
  24.634 +	// first test with the bounding box
  24.635 +	AABox box;
  24.636 +	get_aabbox(&box.min, &box.max);
  24.637 +	if(!box.intersect(ray)) {
  24.638 +		return false;
  24.639 +	}
  24.640 +
  24.641 +	HitPoint nearest_hit;
  24.642 +	nearest_hit.dist = FLT_MAX;
  24.643 +	nearest_hit.obj = 0;
  24.644 +
  24.645 +	if(Mesh::intersect_mode & ISECT_VERTICES) {
  24.646 +		// we asked for "intersections" with the vertices of the mesh
  24.647 +		long nearest_vidx = -1;
  24.648 +		float thres_sq = Mesh::vertex_sel_dist * Mesh::vertex_sel_dist;
  24.649 +
  24.650 +		for(unsigned int i=0; i<nverts; i++) {
  24.651 +
  24.652 +			if((Mesh::intersect_mode & ISECT_FRONT) && dot_product(narr[i], ray.dir) > 0) {
  24.653 +				continue;
  24.654 +			}
  24.655 +
  24.656 +			// project the vertex onto the ray line
  24.657 +			float t = dot_product(varr[i] - ray.origin, ray.dir);
  24.658 +			Vector3 vproj = ray.origin + ray.dir * t;
  24.659 +
  24.660 +			float dist_sq = (vproj - varr[i]).length_sq();
  24.661 +			if(dist_sq < thres_sq) {
  24.662 +				if(!hit) {
  24.663 +					return true;
  24.664 +				}
  24.665 +				if(t < nearest_hit.dist) {
  24.666 +					nearest_hit.dist = t;
  24.667 +					nearest_vidx = i;
  24.668 +				}
  24.669 +			}
  24.670 +		}
  24.671 +
  24.672 +		if(nearest_vidx != -1) {
  24.673 +			hitvert = varr[nearest_vidx];
  24.674 +			nearest_hit.obj = &hitvert;
  24.675 +		}
  24.676 +
  24.677 +	} else {
  24.678 +		// regular intersection test with polygons
  24.679 +
  24.680 +		for(unsigned int i=0; i<nfaces; i++) {
  24.681 +			Triangle face(i, varr, idxarr);
  24.682 +
  24.683 +			// ignore back-facing polygons if the mode flags include ISECT_FRONT
  24.684 +			if((Mesh::intersect_mode & ISECT_FRONT) && dot_product(face.get_normal(), ray.dir) > 0) {
  24.685 +				continue;
  24.686 +			}
  24.687 +
  24.688 +			HitPoint fhit;
  24.689 +			if(face.intersect(ray, hit ? &fhit : 0)) {
  24.690 +				if(!hit) {
  24.691 +					return true;
  24.692 +				}
  24.693 +				if(fhit.dist < nearest_hit.dist) {
  24.694 +					nearest_hit = fhit;
  24.695 +					hitface = face;
  24.696 +				}
  24.697 +			}
  24.698 +		}
  24.699 +	}
  24.700 +
  24.701 +	if(nearest_hit.obj) {
  24.702 +		if(hit) {
  24.703 +			*hit = nearest_hit;
  24.704 +
  24.705 +			// if we are interested in the mesh and not the faces set obj to this
  24.706 +			if(Mesh::intersect_mode & ISECT_FACE) {
  24.707 +				hit->obj = &hitface;
  24.708 +			} else if(Mesh::intersect_mode & ISECT_VERTICES) {
  24.709 +				hit->obj = &hitvert;
  24.710 +			} else {
  24.711 +				hit->obj = this;
  24.712 +			}
  24.713 +		}
  24.714 +		return true;
  24.715 +	}
  24.716 +	return false;
  24.717 +}
  24.718 +
  24.719 +
  24.720 +// ------ private member functions ------
  24.721 +
  24.722 +void Mesh::calc_aabb()
  24.723 +{
  24.724 +	// the cast is to force calling the const version which doesn't invalidate
  24.725 +	if(!((const Mesh*)this)->get_attrib_data(MESH_ATTR_VERTEX)) {
  24.726 +		return;
  24.727 +	}
  24.728 +
  24.729 +	aabb.min = Vector3(FLT_MAX, FLT_MAX, FLT_MAX);
  24.730 +	aabb.max = -aabb.min;
  24.731 +
  24.732 +	for(unsigned int i=0; i<nverts; i++) {
  24.733 +		Vector4 v = get_attrib(MESH_ATTR_VERTEX, i);
  24.734 +		for(int j=0; j<3; j++) {
  24.735 +			if(v[j] < aabb.min[j]) {
  24.736 +				aabb.min[j] = v[j];
  24.737 +			}
  24.738 +			if(v[j] > aabb.max[j]) {
  24.739 +				aabb.max[j] = v[j];
  24.740 +			}
  24.741 +		}
  24.742 +	}
  24.743 +	aabb_valid = true;
  24.744 +}
  24.745 +
  24.746 +void Mesh::calc_bsph()
  24.747 +{
  24.748 +	// the cast is to force calling the const version which doesn't invalidate
  24.749 +	if(!((const Mesh*)this)->get_attrib_data(MESH_ATTR_VERTEX)) {
  24.750 +		return;
  24.751 +	}
  24.752 +
  24.753 +	Vector3 v;
  24.754 +	bsph.center = Vector3(0, 0, 0);
  24.755 +
  24.756 +	// first find the center
  24.757 +	for(unsigned int i=0; i<nverts; i++) {
  24.758 +		v = get_attrib(MESH_ATTR_VERTEX, i);
  24.759 +		bsph.center += v;
  24.760 +	}
  24.761 +	bsph.center /= (float)nverts;
  24.762 +
  24.763 +	bsph.radius = 0.0f;
  24.764 +	for(unsigned int i=0; i<nverts; i++) {
  24.765 +		v = get_attrib(MESH_ATTR_VERTEX, i);
  24.766 +		float dist_sq = (v - bsph.center).length_sq();
  24.767 +		if(dist_sq > bsph.radius) {
  24.768 +			bsph.radius = dist_sq;
  24.769 +		}
  24.770 +	}
  24.771 +	bsph.radius = sqrt(bsph.radius);
  24.772 +
  24.773 +	bsph_valid = true;
  24.774 +}
  24.775 +
  24.776 +void Mesh::update_buffers()
  24.777 +{
  24.778 +	for(int i=0; i<NUM_MESH_ATTR; i++) {
  24.779 +		if(has_attrib(i) && !vattr[i].vbo_valid) {
  24.780 +			glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
  24.781 +			glBufferData(GL_ARRAY_BUFFER, nverts * vattr[i].nelem * sizeof(float), &vattr[i].data[0], GL_STATIC_DRAW);
  24.782 +			vattr[i].vbo_valid = true;
  24.783 +		}
  24.784 +	}
  24.785 +	glBindBuffer(GL_ARRAY_BUFFER, 0);
  24.786 +
  24.787 +	if(idata_valid && !ibo_valid) {
  24.788 +		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
  24.789 +		glBufferData(GL_ELEMENT_ARRAY_BUFFER, nfaces * 3 * sizeof(unsigned int), &idata[0], GL_STATIC_DRAW);
  24.790 +		ibo_valid = true;
  24.791 +	}
  24.792 +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  24.793 +}
  24.794 +
  24.795 +void Mesh::update_wire_ibo()
  24.796 +{
  24.797 +	update_buffers();
  24.798 +
  24.799 +	if(wire_ibo_valid) {
  24.800 +		return;
  24.801 +	}
  24.802 +
  24.803 +	if(!wire_ibo) {
  24.804 +		glGenBuffers(1, &wire_ibo);
  24.805 +	}
  24.806 +
  24.807 +	unsigned int *wire_idxarr = new unsigned int[nfaces * 6];
  24.808 +	unsigned int *dest = wire_idxarr;
  24.809 +
  24.810 +	if(ibo_valid) {
  24.811 +		// we're dealing with an indexed mesh
  24.812 +		const unsigned int *idxarr = ((const Mesh*)this)->get_index_data();
  24.813 +
  24.814 +		for(unsigned int i=0; i<nfaces; i++) {
  24.815 +			*dest++ = idxarr[0];
  24.816 +			*dest++ = idxarr[1];
  24.817 +			*dest++ = idxarr[1];
  24.818 +			*dest++ = idxarr[2];
  24.819 +			*dest++ = idxarr[2];
  24.820 +			*dest++ = idxarr[0];
  24.821 +			idxarr += 3;
  24.822 +		}
  24.823 +	} else {
  24.824 +		// not an indexed mesh ...
  24.825 +		for(unsigned int i=0; i<nfaces; i++) {
  24.826 +			int vidx = i * 3;
  24.827 +			*dest++ = vidx;
  24.828 +			*dest++ = vidx + 1;
  24.829 +			*dest++ = vidx + 1;
  24.830 +			*dest++ = vidx + 2;
  24.831 +			*dest++ = vidx + 2;
  24.832 +			*dest++ = vidx;
  24.833 +		}
  24.834 +	}
  24.835 +
  24.836 +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);
  24.837 +	glBufferData(GL_ELEMENT_ARRAY_BUFFER, nfaces * 6 * sizeof(unsigned int), wire_idxarr, GL_STATIC_DRAW);
  24.838 +	delete [] wire_idxarr;
  24.839 +	wire_ibo_valid = true;
  24.840 +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  24.841 +}
  24.842 +
  24.843 +
  24.844 +// ------ class Triangle ------
  24.845 +Triangle::Triangle()
  24.846 +{
  24.847 +	normal_valid = false;
  24.848 +	id = -1;
  24.849 +}
  24.850 +
  24.851 +Triangle::Triangle(const Vector3 &v0, const Vector3 &v1, const Vector3 &v2)
  24.852 +{
  24.853 +	v[0] = v0;
  24.854 +	v[1] = v1;
  24.855 +	v[2] = v2;
  24.856 +	normal_valid = false;
  24.857 +	id = -1;
  24.858 +}
  24.859 +
  24.860 +Triangle::Triangle(int n, const Vector3 *varr, const unsigned int *idxarr)
  24.861 +{
  24.862 +	if(idxarr) {
  24.863 +		v[0] = varr[idxarr[n * 3]];
  24.864 +		v[1] = varr[idxarr[n * 3 + 1]];
  24.865 +		v[2] = varr[idxarr[n * 3 + 2]];
  24.866 +	} else {
  24.867 +		v[0] = varr[n * 3];
  24.868 +		v[1] = varr[n * 3 + 1];
  24.869 +		v[2] = varr[n * 3 + 2];
  24.870 +	}
  24.871 +	normal_valid = false;
  24.872 +	id = n;
  24.873 +}
  24.874 +
  24.875 +void Triangle::calc_normal()
  24.876 +{
  24.877 +	normal = cross_product(v[1] - v[0], v[2] - v[0]).normalized();
  24.878 +	normal_valid = true;
  24.879 +}
  24.880 +
  24.881 +const Vector3 &Triangle::get_normal() const
  24.882 +{
  24.883 +	if(!normal_valid) {
  24.884 +		((Triangle*)this)->calc_normal();
  24.885 +	}
  24.886 +	return normal;
  24.887 +}
  24.888 +
  24.889 +void Triangle::transform(const Matrix4x4 &xform)
  24.890 +{
  24.891 +	v[0].transform(xform);
  24.892 +	v[1].transform(xform);
  24.893 +	v[2].transform(xform);
  24.894 +	normal_valid = false;
  24.895 +}
  24.896 +
  24.897 +void Triangle::draw() const
  24.898 +{
  24.899 +	Vector3 n[3];
  24.900 +	n[0] = get_normal();
  24.901 +	n[1] = get_normal();
  24.902 +	n[2] = get_normal();
  24.903 +
  24.904 +	int vloc = Mesh::get_attrib_location(MESH_ATTR_VERTEX);
  24.905 +	int nloc = Mesh::get_attrib_location(MESH_ATTR_NORMAL);
  24.906 +
  24.907 +	glEnableVertexAttribArray(vloc);
  24.908 +	glVertexAttribPointer(vloc, 3, GL_FLOAT, GL_FALSE, 0, &v[0].x);
  24.909 +	glVertexAttribPointer(nloc, 3, GL_FLOAT, GL_FALSE, 0, &n[0].x);
  24.910 +
  24.911 +	glDrawArrays(GL_TRIANGLES, 0, 3);
  24.912 +
  24.913 +	glDisableVertexAttribArray(vloc);
  24.914 +	glDisableVertexAttribArray(nloc);
  24.915 +	CHECKGLERR;
  24.916 +}
  24.917 +
  24.918 +void Triangle::draw_wire() const
  24.919 +{
  24.920 +	static const int idxarr[] = {0, 1, 1, 2, 2, 0};
  24.921 +	int vloc = Mesh::get_attrib_location(MESH_ATTR_VERTEX);
  24.922 +
  24.923 +	glEnableVertexAttribArray(vloc);
  24.924 +	glVertexAttribPointer(vloc, 3, GL_FLOAT, GL_FALSE, 0, &v[0].x);
  24.925 +
  24.926 +	glDrawElements(GL_LINES, 6, GL_UNSIGNED_INT, idxarr);
  24.927 +
  24.928 +	glDisableVertexAttribArray(vloc);
  24.929 +	CHECKGLERR;
  24.930 +}
  24.931 +
  24.932 +Vector3 Triangle::calc_barycentric(const Vector3 &pos) const
  24.933 +{
  24.934 +	Vector3 norm = get_normal();
  24.935 +
  24.936 +	float area_sq = fabs(dot_product(cross_product(v[1] - v[0], v[2] - v[0]), norm));
  24.937 +	if(area_sq < 1e-5) {
  24.938 +		return Vector3(0, 0, 0);
  24.939 +	}
  24.940 +
  24.941 +	float asq0 = fabs(dot_product(cross_product(v[1] - pos, v[2] - pos), norm));
  24.942 +	float asq1 = fabs(dot_product(cross_product(v[2] - pos, v[0] - pos), norm));
  24.943 +	float asq2 = fabs(dot_product(cross_product(v[0] - pos, v[1] - pos), norm));
  24.944 +
  24.945 +	return Vector3(asq0 / area_sq, asq1 / area_sq, asq2 / area_sq);
  24.946 +}
  24.947 +
  24.948 +bool Triangle::intersect(const Ray &ray, HitPoint *hit) const
  24.949 +{
  24.950 +	Vector3 normal = get_normal();
  24.951 +
  24.952 +	float ndotdir = dot_product(ray.dir, normal);
  24.953 +	if(fabs(ndotdir) < 1e-4) {
  24.954 +		return false;
  24.955 +	}
  24.956 +
  24.957 +	Vector3 vertdir = v[0] - ray.origin;
  24.958 +	float t = dot_product(normal, vertdir) / ndotdir;
  24.959 +
  24.960 +	Vector3 pos = ray.origin + ray.dir * t;
  24.961 +	Vector3 bary = calc_barycentric(pos);
  24.962 +
  24.963 +	if(bary.x + bary.y + bary.z > 1.00001) {
  24.964 +		return false;
  24.965 +	}
  24.966 +
  24.967 +	if(hit) {
  24.968 +		hit->dist = t;
  24.969 +		hit->pos = ray.origin + ray.dir * t;
  24.970 +		hit->normal = normal;
  24.971 +		hit->obj = this;
  24.972 +	}
  24.973 +	return true;
  24.974 +}

    25.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    25.2 +++ b/src/mesh.h	Thu Nov 14 05:27:09 2013 +0200
    25.3 @@ -0,0 +1,211 @@
    25.4 +#ifndef MESH_H_
    25.5 +#define MESH_H_
    25.6 +
    25.7 +#include <string>
    25.8 +#include <vector>
    25.9 +#include <vmath/vmath.h>
   25.10 +#include "geom.h"
   25.11 +
   25.12 +enum {
   25.13 +	MESH_ATTR_VERTEX,
   25.14 +	MESH_ATTR_NORMAL,
   25.15 +	MESH_ATTR_TANGENT,
   25.16 +	MESH_ATTR_TEXCOORD,
   25.17 +	MESH_ATTR_COLOR,
   25.18 +	MESH_ATTR_BONEWEIGHTS,
   25.19 +	MESH_ATTR_BONEIDX,
   25.20 +
   25.21 +	NUM_MESH_ATTR
   25.22 +};
   25.23 +
   25.24 +// intersection mode flags
   25.25 +enum {
   25.26 +	ISECT_DEFAULT	= 0,	// default (whole mesh, all intersections)
   25.27 +	ISECT_FRONT		= 1,	// front-faces only
   25.28 +	ISECT_FACE		= 2,	// return intersected face pointer instead of mesh
   25.29 +	ISECT_VERTICES	= 4		// return (?) TODO
   25.30 +};
   25.31 +
   25.32 +class XFormNode;
   25.33 +
   25.34 +
   25.35 +class Triangle {
   25.36 +public:
   25.37 +	Vector3 v[3];
   25.38 +	Vector3 normal;
   25.39 +	bool normal_valid;
   25.40 +	int id;
   25.41 +
   25.42 +	Triangle();
   25.43 +	Triangle(const Vector3 &v0, const Vector3 &v1, const Vector3 &v2);
   25.44 +	Triangle(int n, const Vector3 *varr, const unsigned int *idxarr = 0);
   25.45 +
   25.46 +	/// calculate normal (quite expensive)
   25.47 +	void calc_normal();
   25.48 +	const Vector3 &get_normal() const;
   25.49 +
   25.50 +	void transform(const Matrix4x4 &xform);
   25.51 +
   25.52 +	void draw() const;
   25.53 +	void draw_wire() const;
   25.54 +
   25.55 +	/// calculate barycentric coordinates of a point
   25.56 +	Vector3 calc_barycentric(const Vector3 &pos) const;
   25.57 +
   25.58 +	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
   25.59 +};
   25.60 +
   25.61 +
   25.62 +class Mesh {
   25.63 +private:
   25.64 +	std::string name;
   25.65 +	unsigned int nverts, nfaces;
   25.66 +
   25.67 +	// current value for each attribute for the immedate mode
   25.68 +	// interface.
   25.69 +	Vector4 cur_val[NUM_MESH_ATTR];
   25.70 +
   25.71 +	unsigned int buffer_objects[NUM_MESH_ATTR + 1];
   25.72 +
   25.73 +	// vertex attribute data and buffer objects
   25.74 +	struct {
   25.75 +		int nelem;					// number of elements per attribute range: [1, 4]
   25.76 +		std::vector<float> data;
   25.77 +		unsigned int vbo;
   25.78 +		mutable bool vbo_valid;		// if this is false, the vbo needs updating from the data
   25.79 +		mutable bool data_valid;	// if this is false, the data needs to be pulled from the vbo
   25.80 +		//int sdr_loc;
   25.81 +	} vattr[NUM_MESH_ATTR];
   25.82 +
   25.83 +	static int global_sdr_loc[NUM_MESH_ATTR];
   25.84 +
   25.85 +	std::vector<XFormNode*> bones;	// bones affecting this mesh
   25.86 +
   25.87 +	// index data and buffer object
   25.88 +	std::vector<unsigned int> idata;
   25.89 +	unsigned int ibo;
   25.90 +	mutable bool ibo_valid;
   25.91 +	mutable bool idata_valid;
   25.92 +
   25.93 +	// index buffer object for wireframe rendering (constructed on demand)
   25.94 +	unsigned int wire_ibo;
   25.95 +	mutable bool wire_ibo_valid;
   25.96 +
   25.97 +	// axis-aligned bounding box
   25.98 +	mutable AABox aabb;
   25.99 +	mutable bool aabb_valid;
  25.100 +
  25.101 +	// bounding sphere
  25.102 +	mutable Sphere bsph;
  25.103 +	mutable bool bsph_valid;
  25.104 +
  25.105 +	// keeps the last intersected face
  25.106 +	mutable Triangle hitface;
  25.107 +	// keeps the last intersected vertex position
  25.108 +	mutable Vector3 hitvert;
  25.109 +
  25.110 +	void calc_aabb();
  25.111 +	void calc_bsph();
  25.112 +
  25.113 +	static unsigned int intersect_mode;
  25.114 +	static float vertex_sel_dist;
  25.115 +
  25.116 +	static float vis_vecsize;
  25.117 +
  25.118 +	/// update the VBOs after data has changed (invalid vbo/ibo)
  25.119 +	void update_buffers();
  25.120 +	/// construct/update the wireframe index buffer (called from draw_wire).
  25.121 +	void update_wire_ibo();
  25.122 +
  25.123 +
  25.124 +public:
  25.125 +	Mesh();
  25.126 +	~Mesh();
  25.127 +
  25.128 +	void set_name(const char *name);
  25.129 +	const char *get_name() const;
  25.130 +
  25.131 +	bool has_attrib(int attr) const;
  25.132 +
  25.133 +	// clears everything about this mesh, and returns to the newly constructed state
  25.134 +	void clear();
  25.135 +
  25.136 +	// access the vertex attribute data
  25.137 +	// if vdata == 0, space is just allocated
  25.138 +	float *set_attrib_data(int attrib, int nelem, unsigned int num, const float *vdata = 0); // invalidates vbo
  25.139 +	float *get_attrib_data(int attrib);	// invalidates vbo
  25.140 +	const float *get_attrib_data(int attrib) const;
  25.141 +
  25.142 +	// simple access to any particular attribute
  25.143 +	void set_attrib(int attrib, int idx, const Vector4 &v); // invalidates vbo
  25.144 +	Vector4 get_attrib(int attrib, int idx) const;
  25.145 +
  25.146 +	// ... same for index data
  25.147 +	unsigned int *set_index_data(int num, const unsigned int *indices = 0); // invalidates ibo
  25.148 +	unsigned int *get_index_data();	// invalidates ibo
  25.149 +	const unsigned int *get_index_data() const;
  25.150 +
  25.151 +	void append(const Mesh &mesh);
  25.152 +
  25.153 +	// immediate-mode style mesh construction interface
  25.154 +	void vertex(float x, float y, float z);
  25.155 +	void normal(float nx, float ny, float nz);
  25.156 +	void tangent(float tx, float ty, float tz);
  25.157 +	void texcoord(float u, float v, float w);
  25.158 +	void boneweights(float w1, float w2, float w3, float w4);
  25.159 +	void boneidx(int idx1, int idx2, int idx3, int idx4);
  25.160 +
  25.161 +	/* apply a transformation to the vertices and its inverse-transpose
  25.162 +	 * to the normals and tangents.
  25.163 +	 */
  25.164 +	void apply_xform(const Matrix4x4 &xform);
  25.165 +	void apply_xform(const Matrix4x4 &xform, const Matrix4x4 &dir_xform);
  25.166 +
  25.167 +	// adds a bone and returns its index
  25.168 +	int add_bone(XFormNode *bone);
  25.169 +	const XFormNode *get_bone(int idx) const;
  25.170 +	int get_bones_count() const;
  25.171 +
  25.172 +	// access the shader attribute locations
  25.173 +	static void set_attrib_location(int attr, int loc);
  25.174 +	static int get_attrib_location(int attr);
  25.175 +	static void clear_attrib_locations();
  25.176 +
  25.177 +	static void set_vis_vecsize(float sz);
  25.178 +	static float get_vis_vecsize();
  25.179 +
  25.180 +	void draw() const;
  25.181 +	void draw_wire() const;
  25.182 +	void draw_vertices() const;
  25.183 +	void draw_normals() const;
  25.184 +	void draw_tangents() const;
  25.185 +
  25.186 +	/** get the bounding box in local space. The result will be cached, and subsequent
  25.187 +	 * calls will return the same box. The cache gets invalidated by any functions that can affect
  25.188 +	 * the vertex data (non-const variant of get_attrib_data(MESH_ATTR_VERTEX, ...) included).
  25.189 +	 * @{ */
  25.190 +	void get_aabbox(Vector3 *vmin, Vector3 *vmax) const;
  25.191 +	const AABox &get_aabbox() const;
  25.192 +	/// @}
  25.193 +
  25.194 +	/** get the bounding sphere in local space. The result will be cached, and subsequent
  25.195 +	 * calls will return the same box. The cache gets invalidated by any functions that can affect
  25.196 +	 * the vertex data (non-const variant of get_attrib_data(MESH_ATTR_VERTEX, ...) included).
  25.197 +	 * @{ */
  25.198 +	float get_bsphere(Vector3 *center, float *rad) const;
  25.199 +	const Sphere &get_bsphere() const;
  25.200 +
  25.201 +	static void set_intersect_mode(unsigned int mode);
  25.202 +	static unsigned int get_intersect_mode();
  25.203 +	static void set_vertex_select_distance(float dist);
  25.204 +	static float get_vertex_select_distance();
  25.205 +
  25.206 +	/** Find the intersection between the mesh and a ray.
  25.207 +	 * XXX Brute force at the moment, not intended to be used for anything other than picking in tools.
  25.208 +	 *     If you intend to use it in a speed-critical part of the code, you'll *have* to optimize it!
  25.209 +	 */
  25.210 +	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
  25.211 +};
  25.212 +
  25.213 +
  25.214 +#endif	// MESH_H_

    26.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    26.2 +++ b/src/meshgen.cc	Thu Nov 14 05:27:09 2013 +0200
    26.3 @@ -0,0 +1,373 @@
    26.4 +#include "meshgen.h"
    26.5 +#include "mesh.h"
    26.6 +#include "logger.h"
    26.7 +
    26.8 +// -------- sphere --------
    26.9 +
   26.10 +#define SURAD(u)	((u) * 2.0 * M_PI)
   26.11 +#define SVRAD(v)	((v) * M_PI)
   26.12 +
   26.13 +static Vector3 sphvec(float theta, float phi)
   26.14 +{
   26.15 +	return Vector3(sin(theta) * sin(phi),
   26.16 +			cos(phi),
   26.17 +			cos(theta) * sin(phi));
   26.18 +}
   26.19 +
   26.20 +void gen_sphere(Mesh *mesh, float rad, int usub, int vsub, float urange, float vrange)
   26.21 +{
   26.22 +	if(usub < 4) usub = 4;
   26.23 +	if(vsub < 2) vsub = 2;
   26.24 +
   26.25 +	int uverts = usub + 1;
   26.26 +	int vverts = vsub + 1;
   26.27 +
   26.28 +	int num_verts = uverts * vverts;
   26.29 +	int num_quads = usub * vsub;
   26.30 +	int num_tri = num_quads * 2;
   26.31 +
   26.32 +	mesh->clear();
   26.33 +	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
   26.34 +	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
   26.35 +	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
   26.36 +	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
   26.37 +	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
   26.38 +
   26.39 +	float du = urange / (float)(uverts - 1);
   26.40 +	float dv = vrange / (float)(vverts - 1);
   26.41 +
   26.42 +	float u = 0.0;
   26.43 +	for(int i=0; i<uverts; i++) {
   26.44 +		float theta = SURAD(u * urange);
   26.45 +
   26.46 +		float v = 0.0;
   26.47 +		for(int j=0; j<vverts; j++) {
   26.48 +			float phi = SVRAD(v * vrange);
   26.49 +
   26.50 +			Vector3 pos = sphvec(theta, phi);
   26.51 +
   26.52 +			*varr++ = pos * rad;
   26.53 +			*narr++ = pos;
   26.54 +			*tarr++ = (sphvec(theta + 0.1, M_PI / 2.0) - sphvec(theta - 0.1, M_PI / 2.0)).normalized();
   26.55 +			*uvarr++ = Vector2(u * urange, v * vrange);
   26.56 +
   26.57 +			if(i < usub && j < vsub) {
   26.58 +				int idx = i * vverts + j;
   26.59 +				*idxarr++ = idx;
   26.60 +				*idxarr++ = idx + 1;
   26.61 +				*idxarr++ = idx + vverts + 1;
   26.62 +
   26.63 +				*idxarr++ = idx;
   26.64 +				*idxarr++ = idx + vverts + 1;
   26.65 +				*idxarr++ = idx + vverts;
   26.66 +			}
   26.67 +
   26.68 +			v += dv;
   26.69 +		}
   26.70 +		u += du;
   26.71 +	}
   26.72 +}
   26.73 +
   26.74 +
   26.75 +// -------- cylinder --------
   26.76 +
   26.77 +static Vector3 cylvec(float theta, float height)
   26.78 +{
   26.79 +	return Vector3(sin(theta), height, cos(theta));
   26.80 +}
   26.81 +
   26.82 +void gen_cylinder(Mesh *mesh, float rad, float height, int usub, int vsub, int capsub, float urange, float vrange)
   26.83 +{
   26.84 +	if(usub < 4) usub = 4;
   26.85 +	if(vsub < 1) vsub = 1;
   26.86 +
   26.87 +	int uverts = usub + 1;
   26.88 +	int vverts = vsub + 1;
   26.89 +
   26.90 +	int num_body_verts = uverts * vverts;
   26.91 +	int num_body_quads = usub * vsub;
   26.92 +	int num_body_tri = num_body_quads * 2;
   26.93 +
   26.94 +	int capvverts = capsub ? capsub + 1 : 0;
   26.95 +	int num_cap_verts = uverts * capvverts;
   26.96 +	int num_cap_quads = usub * capsub;
   26.97 +	int num_cap_tri = num_cap_quads * 2;
   26.98 +
   26.99 +	int num_verts = num_body_verts + num_cap_verts * 2;
  26.100 +	int num_tri = num_body_tri + num_cap_tri * 2;
  26.101 +
  26.102 +	mesh->clear();
  26.103 +	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
  26.104 +	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
  26.105 +	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
  26.106 +	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
  26.107 +	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
  26.108 +
  26.109 +	float du = urange / (float)(uverts - 1);
  26.110 +	float dv = vrange / (float)(vverts - 1);
  26.111 +
  26.112 +	float u = 0.0;
  26.113 +	for(int i=0; i<uverts; i++) {
  26.114 +		float theta = SURAD(u);
  26.115 +
  26.116 +		float v = 0.0;
  26.117 +		for(int j=0; j<vverts; j++) {
  26.118 +			float y = (v - 0.5) * height;
  26.119 +			Vector3 pos = cylvec(theta, y);
  26.120 +
  26.121 +			*varr++ = Vector3(pos.x * rad, pos.y, pos.z * rad);
  26.122 +			*narr++ = Vector3(pos.x, 0.0, pos.z);
  26.123 +			*tarr++ = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();
  26.124 +			*uvarr++ = Vector2(u * urange, v * vrange);
  26.125 +
  26.126 +			if(i < usub && j < vsub) {
  26.127 +				int idx = i * vverts + j;
  26.128 +
  26.129 +				*idxarr++ = idx;
  26.130 +				*idxarr++ = idx + vverts + 1;
  26.131 +				*idxarr++ = idx + 1;
  26.132 +
  26.133 +				*idxarr++ = idx;
  26.134 +				*idxarr++ = idx + vverts;
  26.135 +				*idxarr++ = idx + vverts + 1;
  26.136 +			}
  26.137 +
  26.138 +			v += dv;
  26.139 +		}
  26.140 +		u += du;
  26.141 +	}
  26.142 +
  26.143 +
  26.144 +	// now the cap!
  26.145 +	if(!capsub) {
  26.146 +		return;
  26.147 +	}
  26.148 +
  26.149 +	dv = 1.0 / (float)(capvverts - 1);
  26.150 +
  26.151 +	u = 0.0;
  26.152 +	for(int i=0; i<uverts; i++) {
  26.153 +		float theta = SURAD(u);
  26.154 +
  26.155 +		float v = 0.0;
  26.156 +		for(int j=0; j<capvverts; j++) {
  26.157 +			float r = v * rad;
  26.158 +
  26.159 +			Vector3 pos = cylvec(theta, height / 2.0) * r;
  26.160 +			pos.y = height / 2.0;
  26.161 +			Vector3 tang = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();
  26.162 +
  26.163 +			*varr++ = pos;
  26.164 +			*narr++ = Vector3(0, 1, 0);
  26.165 +			*tarr++ = tang;
  26.166 +			*uvarr++ = Vector2(u * urange, v);
  26.167 +
  26.168 +			pos.y = -height / 2.0;
  26.169 +			*varr++ = pos;
  26.170 +			*narr++ = Vector3(0, -1, 0);
  26.171 +			*tarr++ = -tang;
  26.172 +			*uvarr++ = Vector2(u * urange, v);
  26.173 +
  26.174 +			if(i < usub && j < capsub) {
  26.175 +				unsigned int idx = num_body_verts + (i * capvverts + j) * 2;
  26.176 +
  26.177 +				unsigned int vidx[4] = {
  26.178 +					idx,
  26.179 +					idx + capvverts * 2,
  26.180 +					idx + (capvverts + 1) * 2,
  26.181 +					idx + 2
  26.182 +				};
  26.183 +
  26.184 +				*idxarr++ = vidx[0];
  26.185 +				*idxarr++ = vidx[2];
  26.186 +				*idxarr++ = vidx[1];
  26.187 +				*idxarr++ = vidx[0];
  26.188 +				*idxarr++ = vidx[3];
  26.189 +				*idxarr++ = vidx[2];
  26.190 +
  26.191 +				*idxarr++ = vidx[0] + 1;
  26.192 +				*idxarr++ = vidx[1] + 1;
  26.193 +				*idxarr++ = vidx[2] + 1;
  26.194 +				*idxarr++ = vidx[0] + 1;
  26.195 +				*idxarr++ = vidx[2] + 1;
  26.196 +				*idxarr++ = vidx[3] + 1;
  26.197 +			}
  26.198 +
  26.199 +			v += dv;
  26.200 +		}
  26.201 +		u += du;
  26.202 +	}
  26.203 +}
  26.204 +
  26.205 +// -------- cone --------
  26.206 +
  26.207 +static Vector3 conevec(float theta, float y, float height)
  26.208 +{
  26.209 +	float scale = 1.0 - y / height;
  26.210 +	return Vector3(sin(theta) * scale, y, cos(theta) * scale);
  26.211 +}
  26.212 +
  26.213 +void gen_cone(Mesh *mesh, float rad, float height, int usub, int vsub, int capsub, float urange, float vrange)
  26.214 +{
  26.215 +	if(usub < 4) usub = 4;
  26.216 +	if(vsub < 1) vsub = 1;
  26.217 +
  26.218 +	int uverts = usub + 1;
  26.219 +	int vverts = vsub + 1;
  26.220 +
  26.221 +	int num_body_verts = uverts * vverts;
  26.222 +	int num_body_quads = usub * vsub;
  26.223 +	int num_body_tri = num_body_quads * 2;
  26.224 +
  26.225 +	int capvverts = capsub ? capsub + 1 : 0;
  26.226 +	int num_cap_verts = uverts * capvverts;
  26.227 +	int num_cap_quads = usub * capsub;
  26.228 +	int num_cap_tri = num_cap_quads * 2;
  26.229 +
  26.230 +	int num_verts = num_body_verts + num_cap_verts;
  26.231 +	int num_tri = num_body_tri + num_cap_tri;
  26.232 +
  26.233 +	mesh->clear();
  26.234 +	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
  26.235 +	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
  26.236 +	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
  26.237 +	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
  26.238 +	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
  26.239 +
  26.240 +	float du = urange / (float)(uverts - 1);
  26.241 +	float dv = vrange / (float)(vverts - 1);
  26.242 +
  26.243 +	float u = 0.0;
  26.244 +	for(int i=0; i<uverts; i++) {
  26.245 +		float theta = SURAD(u);
  26.246 +
  26.247 +		float v = 0.0;
  26.248 +		for(int j=0; j<vverts; j++) {
  26.249 +			float y = v * height;
  26.250 +			Vector3 pos = conevec(theta, y, height);
  26.251 +
  26.252 +			Vector3 tang = (conevec(theta + 0.1, 0.0, height) - conevec(theta - 0.1, 0.0, height)).normalized();
  26.253 +			Vector3 bitang = (conevec(theta, y + 0.1, height) - pos).normalized();
  26.254 +
  26.255 +			*varr++ = Vector3(pos.x * rad, pos.y, pos.z * rad);
  26.256 +			*narr++ = cross_product(tang, bitang);
  26.257 +			*tarr++ = tang;
  26.258 +			*uvarr++ = Vector2(u * urange, v * vrange);
  26.259 +
  26.260 +			if(i < usub && j < vsub) {
  26.261 +				int idx = i * vverts + j;
  26.262 +
  26.263 +				*idxarr++ = idx;
  26.264 +				*idxarr++ = idx + vverts + 1;
  26.265 +				*idxarr++ = idx + 1;
  26.266 +
  26.267 +				*idxarr++ = idx;
  26.268 +				*idxarr++ = idx + vverts;
  26.269 +				*idxarr++ = idx + vverts + 1;
  26.270 +			}
  26.271 +
  26.272 +			v += dv;
  26.273 +		}
  26.274 +		u += du;
  26.275 +	}
  26.276 +
  26.277 +
  26.278 +	// now the bottom cap!
  26.279 +	if(!capsub) {
  26.280 +		return;
  26.281 +	}
  26.282 +
  26.283 +	dv = 1.0 / (float)(capvverts - 1);
  26.284 +
  26.285 +	u = 0.0;
  26.286 +	for(int i=0; i<uverts; i++) {
  26.287 +		float theta = SURAD(u);
  26.288 +
  26.289 +		float v = 0.0;
  26.290 +		for(int j=0; j<capvverts; j++) {
  26.291 +			float r = v * rad;
  26.292 +
  26.293 +			Vector3 pos = conevec(theta, 0.0, height) * r;
  26.294 +			Vector3 tang = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();
  26.295 +
  26.296 +			*varr++ = pos;
  26.297 +			*narr++ = Vector3(0, -1, 0);
  26.298 +			*tarr++ = tang;
  26.299 +			*uvarr++ = Vector2(u * urange, v);
  26.300 +
  26.301 +			if(i < usub && j < capsub) {
  26.302 +				unsigned int idx = num_body_verts + i * capvverts + j;
  26.303 +
  26.304 +				unsigned int vidx[4] = {
  26.305 +					idx,
  26.306 +					idx + capvverts,
  26.307 +					idx + (capvverts + 1),
  26.308 +					idx + 1
  26.309 +				};
  26.310 +
  26.311 +				*idxarr++ = vidx[0];
  26.312 +				*idxarr++ = vidx[1];
  26.313 +				*idxarr++ = vidx[2];
  26.314 +				*idxarr++ = vidx[0];
  26.315 +				*idxarr++ = vidx[2];
  26.316 +				*idxarr++ = vidx[3];
  26.317 +			}
  26.318 +
  26.319 +			v += dv;
  26.320 +		}
  26.321 +		u += du;
  26.322 +	}
  26.323 +}
  26.324 +
  26.325 +
  26.326 +// -------- plane --------
  26.327 +
  26.328 +void gen_plane(Mesh *mesh, float width, float height, int usub, int vsub)
  26.329 +{
  26.330 +	if(usub < 1) usub = 1;
  26.331 +	if(vsub < 1) vsub = 1;
  26.332 +
  26.333 +	mesh->clear();
  26.334 +
  26.335 +	int uverts = usub + 1;
  26.336 +	int vverts = vsub + 1;
  26.337 +	int num_verts = uverts * vverts;
  26.338 +
  26.339 +	int num_quads = usub * vsub;
  26.340 +	int num_tri = num_quads * 2;
  26.341 +
  26.342 +	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
  26.343 +	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
  26.344 +	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
  26.345 +	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
  26.346 +	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
  26.347 +
  26.348 +	float du = 1.0 / (float)usub;
  26.349 +	float dv = 1.0 / (float)vsub;
  26.350 +
  26.351 +	float u = 0.0;
  26.352 +	for(int i=0; i<uverts; i++) {
  26.353 +		float v = 0.0;
  26.354 +		for(int j=0; j<vverts; j++) {
  26.355 +			*varr++ = Vector3((u - 0.5) * width, (v - 0.5) * height, 0.0);
  26.356 +			*narr++ = Vector3(0, 0, 1);
  26.357 +			*tarr++ = Vector3(1, 0, 0);
  26.358 +			*uvarr++ = Vector2(u, v);
  26.359 +
  26.360 +			if(i < usub && j < vsub) {
  26.361 +				int idx = i * vverts + j;
  26.362 +
  26.363 +				*idxarr++ = idx;
  26.364 +				*idxarr++ = idx + vverts + 1;
  26.365 +				*idxarr++ = idx + 1;
  26.366 +
  26.367 +				*idxarr++ = idx;
  26.368 +				*idxarr++ = idx + vverts;
  26.369 +				*idxarr++ = idx + vverts + 1;
  26.370 +			}
  26.371 +
  26.372 +			v += dv;
  26.373 +		}
  26.374 +		u += du;
  26.375 +	}
  26.376 +}