From b1046f60ec5a30826c97cdf4583580ca4e9d0a46 Mon Sep 17 00:00:00 2001 From: David Rose Date: Wed, 28 Feb 2001 23:55:58 +0000 Subject: [PATCH] *** empty log message *** --- pandatool/src/flt/Sources.pp | 22 +- pandatool/src/flt/config_flt.cxx | 10 + pandatool/src/flt/fltBead.cxx | 9 +- pandatool/src/flt/fltCurve.I | 30 +++ pandatool/src/flt/fltCurve.cxx | 88 +++++++ pandatool/src/flt/fltCurve.h | 66 +++++ pandatool/src/flt/fltExternalReference.cxx | 2 +- pandatool/src/flt/fltFace.I | 55 ---- pandatool/src/flt/fltFace.cxx | 201 +-------------- pandatool/src/flt/fltFace.h | 88 +------ pandatool/src/flt/fltGeometry.I | 60 +++++ pandatool/src/flt/fltGeometry.cxx | 239 ++++++++++++++++++ pandatool/src/flt/fltGeometry.h | 131 ++++++++++ pandatool/src/flt/fltGroup.cxx | 2 +- pandatool/src/flt/fltHeader.cxx | 64 ++++- pandatool/src/flt/fltHeader.h | 5 + pandatool/src/flt/fltInstanceDefinition.cxx | 2 +- pandatool/src/flt/fltInstanceRef.cxx | 2 +- pandatool/src/flt/fltLOD.cxx | 2 +- .../src/flt/fltLightSourceDefinition.cxx | 2 +- pandatool/src/flt/fltLocalVertexPool.I | 4 + pandatool/src/flt/fltLocalVertexPool.cxx | 235 +++++++++++++++++ pandatool/src/flt/fltLocalVertexPool.h | 72 ++++++ pandatool/src/flt/fltMaterial.cxx | 2 +- pandatool/src/flt/fltMesh.I | 4 + pandatool/src/flt/fltMesh.cxx | 118 +++++++++ pandatool/src/flt/fltMesh.h | 56 ++++ pandatool/src/flt/fltMeshPrimitive.I | 4 + pandatool/src/flt/fltMeshPrimitive.cxx | 127 ++++++++++ pandatool/src/flt/fltMeshPrimitive.h | 64 +++++ pandatool/src/flt/fltObject.cxx | 2 +- pandatool/src/flt/fltOpcode.cxx | 40 ++- pandatool/src/flt/fltOpcode.h | 16 +- pandatool/src/flt/fltPackedColor.I | 29 +++ pandatool/src/flt/fltPackedColor.h | 3 + pandatool/src/flt/fltRecord.cxx | 144 ++++++++++- pandatool/src/flt/fltRecord.h | 9 + pandatool/src/flt/fltRecordReader.cxx | 107 ++++++-- pandatool/src/flt/fltRecordReader.h | 6 + pandatool/src/flt/fltRecordWriter.cxx | 61 +++-- pandatool/src/flt/fltTexture.cxx | 40 ++- pandatool/src/flt/fltTexture.h | 10 + .../src/flt/fltTransformGeneralMatrix.cxx | 2 +- pandatool/src/flt/fltTransformPut.cxx | 2 +- .../src/flt/fltTransformRotateAboutEdge.cxx | 2 +- .../src/flt/fltTransformRotateAboutPoint.cxx | 2 +- pandatool/src/flt/fltTransformRotateScale.cxx | 2 +- pandatool/src/flt/fltTransformScale.cxx | 2 +- pandatool/src/flt/fltTransformTranslate.cxx | 2 +- pandatool/src/flt/fltVertex.cxx | 2 +- pandatool/src/flt/fltVertexList.cxx | 2 +- pandatool/src/flt/test_flt.cxx | 4 +- 52 files changed, 1830 insertions(+), 425 deletions(-) create mode 100644 pandatool/src/flt/fltCurve.I create mode 100644 pandatool/src/flt/fltCurve.cxx create mode 100644 pandatool/src/flt/fltCurve.h create mode 100644 pandatool/src/flt/fltGeometry.I create mode 100644 pandatool/src/flt/fltGeometry.cxx create mode 100644 pandatool/src/flt/fltGeometry.h create mode 100644 pandatool/src/flt/fltLocalVertexPool.I create mode 100644 pandatool/src/flt/fltLocalVertexPool.cxx create mode 100644 pandatool/src/flt/fltLocalVertexPool.h create mode 100644 pandatool/src/flt/fltMesh.I create mode 100644 pandatool/src/flt/fltMesh.cxx create mode 100644 pandatool/src/flt/fltMesh.h create mode 100644 pandatool/src/flt/fltMeshPrimitive.I create mode 100644 pandatool/src/flt/fltMeshPrimitive.cxx create mode 100644 pandatool/src/flt/fltMeshPrimitive.h diff --git a/pandatool/src/flt/Sources.pp b/pandatool/src/flt/Sources.pp index 94b95a0df8..35694cabd2 100644 --- a/pandatool/src/flt/Sources.pp +++ b/pandatool/src/flt/Sources.pp @@ -8,13 +8,18 @@ #define SOURCES \ config_flt.cxx config_flt.h fltBead.cxx fltBead.h fltBeadID.cxx \ - fltBeadID.h fltError.cxx fltError.h fltExternalReference.cxx \ + fltBeadID.h fltCurve.I fltCurve.cxx fltCurve.h \ + fltError.cxx fltError.h fltExternalReference.cxx \ fltExternalReference.h fltEyepoint.cxx fltEyepoint.h fltFace.I \ - fltFace.cxx fltFace.h fltGroup.cxx fltGroup.h fltHeader.cxx \ + fltFace.cxx fltFace.h fltGeometry.I fltGeometry.cxx fltGeometry.h \ + fltGroup.cxx fltGroup.h fltHeader.cxx \ fltHeader.h fltInstanceDefinition.cxx fltInstanceDefinition.h \ fltInstanceRef.cxx fltInstanceRef.h fltLOD.cxx fltLOD.h \ fltLightSourceDefinition.cxx fltLightSourceDefinition.h \ - fltMaterial.cxx fltMaterial.h fltObject.cxx fltObject.h \ + fltLocalVertexPool.I fltLocalVertexPool.cxx fltLocalVertexPool.h \ + fltMaterial.cxx fltMaterial.h fltMesh.I fltMesh.cxx fltMesh.h \ + fltMeshPrimitive.I fltMeshPrimitive.cxx fltMeshPrimitive.h \ + fltObject.cxx fltObject.h \ fltOpcode.cxx fltOpcode.h fltPackedColor.I fltPackedColor.cxx \ fltPackedColor.h fltRecord.I fltRecord.cxx fltRecord.h \ fltRecordReader.cxx fltRecordReader.h fltRecordWriter.cxx \ @@ -31,10 +36,15 @@ fltVertexList.cxx fltVertexList.h #define INSTALL_HEADERS \ - fltBead.h fltBeadID.h fltError.h fltExternalReference.h \ - fltEyepoint.h fltFace.I fltFace.h fltGroup.h fltHeader.h \ + fltBead.h fltBeadID.h fltCurve.I fltCurve.h \ + fltError.h fltExternalReference.h \ + fltEyepoint.h fltFace.I fltFace.h fltGeometry.I fltGeometry.h \ + fltGroup.h fltHeader.h \ fltInstanceDefinition.h fltInstanceRef.h fltLOD.h \ - fltLightSourceDefinition.h fltMaterial.h fltObject.h fltOpcode.h \ + fltLightSourceDefinition.h fltLocalVertexPool.I fltLocalVertexPool.h \ + fltMaterial.h fltMesh.I fltMesh.h \ + fltMeshPrimitive.I fltMeshPrimitive.h \ + fltObject.h fltOpcode.h \ fltPackedColor.I fltPackedColor.h fltRecord.I fltRecord.h \ fltRecordReader.h fltRecordWriter.h fltTexture.h fltTrackplane.h \ fltTransformGeneralMatrix.h fltTransformPut.h fltTransformRecord.h \ diff --git a/pandatool/src/flt/config_flt.cxx b/pandatool/src/flt/config_flt.cxx index 1df839bf17..d739c99775 100644 --- a/pandatool/src/flt/config_flt.cxx +++ b/pandatool/src/flt/config_flt.cxx @@ -9,7 +9,12 @@ #include "fltBeadID.h" #include "fltGroup.h" #include "fltObject.h" +#include "fltGeometry.h" #include "fltFace.h" +#include "fltCurve.h" +#include "fltMesh.h" +#include "fltLocalVertexPool.h" +#include "fltMeshPrimitive.h" #include "fltVertexList.h" #include "fltLOD.h" #include "fltInstanceDefinition.h" @@ -48,7 +53,12 @@ ConfigureFn(config_flt) { FltBeadID::init_type(); FltGroup::init_type(); FltObject::init_type(); + FltGeometry::init_type(); FltFace::init_type(); + FltCurve::init_type(); + FltMesh::init_type(); + FltLocalVertexPool::init_type(); + FltMeshPrimitive::init_type(); FltVertexList::init_type(); FltLOD::init_type(); FltInstanceDefinition::init_type(); diff --git a/pandatool/src/flt/fltBead.cxx b/pandatool/src/flt/fltBead.cxx index b8aae5ade4..e5bc8a57dd 100644 --- a/pandatool/src/flt/fltBead.cxx +++ b/pandatool/src/flt/fltBead.cxx @@ -229,7 +229,9 @@ extract_ancillary(FltRecordReader &reader) { // A transform step. nassertr(step != (FltTransformRecord *)NULL, false); - step->extract_record(reader); + if (!step->extract_record(reader)) { + return false; + } _transform_steps.push_back(DCAST(FltTransformRecord, step)); /* @@ -305,7 +307,7 @@ extract_transform_matrix(FltRecordReader &reader) { matrix(r, c) = iterator.get_be_float32(); } } - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); _transform_steps.clear(); _has_transform = true; @@ -327,8 +329,7 @@ extract_replicate_count(FltRecordReader &reader) { _replicate_count = iterator.get_be_int16(); iterator.skip_bytes(2); - nassertr(iterator.get_remaining_size() == 0, true); - + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltCurve.I b/pandatool/src/flt/fltCurve.I new file mode 100644 index 0000000000..51000e6972 --- /dev/null +++ b/pandatool/src/flt/fltCurve.I @@ -0,0 +1,30 @@ +// Filename: fltCurve.I +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////// +// Function: FltCurve::get_num_control_points +// Access: Public +// Description: Returns the number of control points assigned to the +// curve. +//////////////////////////////////////////////////////////////////// +INLINE int FltCurve:: +get_num_control_points() const { + return _control_points.size(); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltCurve::get_control_point +// Access: Public +// Description: Returns the nth control point assigned to the curve. +//////////////////////////////////////////////////////////////////// +INLINE const LPoint3d &FltCurve:: +get_control_point(int n) const { +#ifndef NDEBUG + static LPoint3d bogus(0.0, 0.0, 0.0); + nassertr(n >= 0 && n < (int)_control_points.size(), bogus); +#endif + return _control_points[n]; +} diff --git a/pandatool/src/flt/fltCurve.cxx b/pandatool/src/flt/fltCurve.cxx new file mode 100644 index 0000000000..a5b4bf3b5a --- /dev/null +++ b/pandatool/src/flt/fltCurve.cxx @@ -0,0 +1,88 @@ +// Filename: fltCurve.cxx +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#include "fltCurve.h" +#include "fltRecordReader.h" +#include "fltRecordWriter.h" +#include "fltHeader.h" +#include "fltMaterial.h" + +TypeHandle FltCurve::_type_handle; + +//////////////////////////////////////////////////////////////////// +// Function: FltCurve::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +FltCurve:: +FltCurve(FltHeader *header) : FltBeadID(header) { + _curve_type = CT_b_spline; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltCurve::extract_record +// Access: Protected, Virtual +// Description: Fills in the information in this bead based on the +// information given in the indicated datagram, whose +// opcode has already been read. Returns true on +// success, false if the datagram is invalid. +//////////////////////////////////////////////////////////////////// +bool FltCurve:: +extract_record(FltRecordReader &reader) { + if (!FltBeadID::extract_record(reader)) { + return false; + } + + nassertr(reader.get_opcode() == FO_curve, false); + DatagramIterator &iterator = reader.get_iterator(); + + iterator.skip_bytes(4); + _curve_type = (CurveType)iterator.get_be_int32(); + + int num_control_points = iterator.get_be_int32(); + iterator.skip_bytes(8); + for (int i = 0; i < num_control_points; i++) { + double x = iterator.get_be_float64(); + double y = iterator.get_be_float64(); + double z = iterator.get_be_float64(); + _control_points.push_back(LPoint3d(x, y, z)); + } + + check_remaining_size(iterator); + return true; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltCurve::build_record +// Access: Protected, Virtual +// Description: Fills up the current record on the FltRecordWriter with +// data for this record, but does not advance the +// writer. Returns true on success, false if there is +// some error. +//////////////////////////////////////////////////////////////////// +bool FltCurve:: +build_record(FltRecordWriter &writer) const { + if (!FltBeadID::build_record(writer)) { + return false; + } + + writer.set_opcode(FO_curve); + Datagram &datagram = writer.update_datagram(); + + datagram.pad_bytes(4); + datagram.add_be_int32(_curve_type); + datagram.add_be_int32(_control_points.size()); + datagram.pad_bytes(8); + + ControlPoints::const_iterator ci; + for (ci = _control_points.begin(); ci != _control_points.end(); ++ci) { + const LPoint3d &p = (*ci); + datagram.add_be_float64(p[0]); + datagram.add_be_float64(p[1]); + datagram.add_be_float64(p[2]); + } + + return true; +} diff --git a/pandatool/src/flt/fltCurve.h b/pandatool/src/flt/fltCurve.h new file mode 100644 index 0000000000..fffd1c8d28 --- /dev/null +++ b/pandatool/src/flt/fltCurve.h @@ -0,0 +1,66 @@ +// Filename: fltCurve.h +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#ifndef FLTCURVE_H +#define FLTCURVE_H + +#include + +#include "fltBeadID.h" +#include "fltHeader.h" + +#include + +//////////////////////////////////////////////////////////////////// +// Class : FltCurve +// Description : A single curve, like a Bezier or B-Spline. +//////////////////////////////////////////////////////////////////// +class FltCurve : public FltBeadID { +public: + FltCurve(FltHeader *header); + + enum CurveType { + CT_b_spline = 4, + CT_cardinal = 5, + CT_bezier = 6 + }; + + typedef vector ControlPoints; + + CurveType _curve_type; + ControlPoints _control_points; + +public: + INLINE int get_num_control_points() const; + INLINE const LPoint3d &get_control_point(int n) const; + + +protected: + virtual bool extract_record(FltRecordReader &reader); + virtual bool build_record(FltRecordWriter &writer) const; + +public: + virtual TypeHandle get_type() const { + return get_class_type(); + } + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + static TypeHandle get_class_type() { + return _type_handle; + } + static void init_type() { + FltBeadID::init_type(); + register_type(_type_handle, "FltCurve", + FltBeadID::get_class_type()); + } + +private: + static TypeHandle _type_handle; +}; + +#include "fltCurve.I" + +#endif + + diff --git a/pandatool/src/flt/fltExternalReference.cxx b/pandatool/src/flt/fltExternalReference.cxx index be9f98d96f..4919a25c90 100644 --- a/pandatool/src/flt/fltExternalReference.cxx +++ b/pandatool/src/flt/fltExternalReference.cxx @@ -86,7 +86,7 @@ extract_record(FltRecordReader &reader) { } } - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltFace.I b/pandatool/src/flt/fltFace.I index 6abd553edf..325bc5a1cc 100644 --- a/pandatool/src/flt/fltFace.I +++ b/pandatool/src/flt/fltFace.I @@ -3,58 +3,3 @@ // //////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::has_texture -// Access: Public -// Description: Returns true if the face has a texture applied, false -// otherwise. -//////////////////////////////////////////////////////////////////// -INLINE bool FltFace:: -has_texture() const { - return (_texture_index >= 0 && _header->has_texture(_texture_index)); -} - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::get_texture -// Access: Public -// Description: Returns the texture applied to this face, or NULL if -// no texture was applied. -//////////////////////////////////////////////////////////////////// -INLINE FltTexture *FltFace:: -get_texture() const { - return _header->get_texture(_texture_index); -} - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::has_material -// Access: Public -// Description: Returns true if the face has a material applied, false -// otherwise. -//////////////////////////////////////////////////////////////////// -INLINE bool FltFace:: -has_material() const { - return (_material_index >= 0 && _header->has_material(_material_index)); -} - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::get_material -// Access: Public -// Description: Returns the material applied to this face, or NULL if -// no material was applied. -//////////////////////////////////////////////////////////////////// -INLINE FltMaterial *FltFace:: -get_material() const { - return _header->get_material(_material_index); -} - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::has_color -// Access: Public -// Description: Returns true if the face has a primary color -// indicated, false otherwise. -//////////////////////////////////////////////////////////////////// -INLINE bool FltFace:: -has_color() const { - return ((_flags & F_no_color) == 0) || has_material(); -} diff --git a/pandatool/src/flt/fltFace.cxx b/pandatool/src/flt/fltFace.cxx index 4b62cbff88..823f8d50f3 100644 --- a/pandatool/src/flt/fltFace.cxx +++ b/pandatool/src/flt/fltFace.cxx @@ -17,125 +17,7 @@ TypeHandle FltFace::_type_handle; // Description: //////////////////////////////////////////////////////////////////// FltFace:: -FltFace(FltHeader *header) : FltBeadID(header) { - _ir_color = 0; - _relative_priority = 0; - _draw_type = DT_solid_backface; - _texwhite = false; - _color_name_index = 0; - _alt_color_name_index = 0; - _billboard_type = BT_none; - _detail_texture_index = -1; - _texture_index = -1; - _material_index = -1; - _dfad_material_code = 0; - _dfad_feature_id = 0; - _ir_material_code = 0; - _transparency = 0; - _lod_generation_control = 0; - _line_style_index = 0; - _flags = 0; - _light_mode = LM_face_no_normal; - _texture_mapping_index = 0; - _color_index = 0; - _alt_color_index = 0; -} - - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::get_color -// Access: Public -// Description: If has_color() indicates true, returns the primary -// color of the face, as a four-component value -// (including alpha as the transparency channel). -//////////////////////////////////////////////////////////////////// -Colorf FltFace:: -get_color() const { - nassertr(has_color(), Colorf(0.0, 0.0, 0.0, 0.0)); - - if (_texwhite && has_texture()) { - // Force this one white. - return Colorf(1.0, 1.0, 1.0, 1.0 - (_transparency / 65535.0)); - } - - if (has_material()) { - // If we have a material, that replaces the color. - FltMaterial *material = get_material(); - return Colorf(material->_diffuse[0], - material->_diffuse[1], - material->_diffuse[2], - 1.0 - (_transparency / 65535.0)); - } - - return _header->get_color(_color_index, (_flags & F_packed_color) != 0, - _packed_color, _transparency); -} - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::get_rgb -// Access: Public -// Description: If has_color() indicates true, returns the primary -// color of the face, as a three-component value -// ignoring transparency. -//////////////////////////////////////////////////////////////////// -RGBColorf FltFace:: -get_rgb() const { - nassertr(has_color(), RGBColorf(0.0, 0.0, 0.0)); - - if (_texwhite && has_texture()) { - // Force this one white. - return RGBColorf(1.0, 1.0, 1.0); - } - - if (has_material()) { - // If we have a material, that replaces the color. - FltMaterial *material = get_material(); - return material->_diffuse; - } - - return _header->get_rgb(_color_index, (_flags & F_packed_color) != 0, - _packed_color); -} - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::has_alt_color -// Access: Public -// Description: Returns true if the face has an alternate color -// indicated, false otherwise. -//////////////////////////////////////////////////////////////////// -bool FltFace:: -has_alt_color() const { - return (_flags & F_no_alt_color) == 0; -} - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::get_alt_color -// Access: Public -// Description: If has_alt_color() indicates true, returns the alternate -// color of the face, as a four-component value -// (including alpha as the transparency channel). -//////////////////////////////////////////////////////////////////// -Colorf FltFace:: -get_alt_color() const { - nassertr(has_alt_color(), Colorf(0.0, 0.0, 0.0, 0.0)); - - return _header->get_color(_alt_color_index, (_flags & F_packed_color) != 0, - _alt_packed_color, _transparency); -} - -//////////////////////////////////////////////////////////////////// -// Function: FltFace::get_alt_rgb -// Access: Public -// Description: If has_alt_color() indicates true, returns the alternate -// color of the face, as a three-component value -// ignoring transparency. -//////////////////////////////////////////////////////////////////// -RGBColorf FltFace:: -get_alt_rgb() const { - nassertr(has_alt_color(), RGBColorf(0.0, 0.0, 0.0)); - - return _header->get_rgb(_alt_color_index, (_flags & F_packed_color) != 0, - _alt_packed_color); +FltFace(FltHeader *header) : FltGeometry(header) { } //////////////////////////////////////////////////////////////////// @@ -151,46 +33,14 @@ extract_record(FltRecordReader &reader) { if (!FltBeadID::extract_record(reader)) { return false; } + if (!FltGeometry::extract_record(reader)) { + return false; + } nassertr(reader.get_opcode() == FO_face, false); + DatagramIterator &iterator = reader.get_iterator(); - - _ir_color = iterator.get_be_int32(); - _relative_priority = iterator.get_be_int16(); - _draw_type = (DrawType)iterator.get_int8(); - _texwhite = (iterator.get_int8() != 0); - _color_name_index = iterator.get_be_int16(); - _alt_color_name_index = iterator.get_be_int16(); - iterator.skip_bytes(1); - _billboard_type = (BillboardType)iterator.get_int8(); - _detail_texture_index = iterator.get_be_int16(); - _texture_index = iterator.get_be_int16(); - _material_index = iterator.get_be_int16(); - _dfad_material_code = iterator.get_be_int16(); - _dfad_feature_id = iterator.get_be_int16(); - _ir_material_code = iterator.get_be_int32(); - _transparency = iterator.get_be_uint16(); - _lod_generation_control = iterator.get_uint8(); - _line_style_index = iterator.get_uint8(); - _flags = iterator.get_be_uint32(); - _light_mode = (LightMode)iterator.get_uint8(); - iterator.skip_bytes(1 + 4); - iterator.skip_bytes(2); // Undocumented padding. - - if (!_packed_color.extract_record(reader)) { - return false; - } - if (!_alt_packed_color.extract_record(reader)) { - return false; - } - - _texture_mapping_index = iterator.get_be_int16(); - iterator.skip_bytes(2); - _color_index = iterator.get_be_uint32(); - _alt_color_index = iterator.get_be_uint32(); - iterator.skip_bytes(2 + 2); - - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } @@ -207,44 +57,11 @@ build_record(FltRecordWriter &writer) const { if (!FltBeadID::build_record(writer)) { return false; } + if (!FltGeometry::build_record(writer)) { + return false; + } writer.set_opcode(FO_face); - Datagram &datagram = writer.update_datagram(); - - datagram.add_be_int32(_ir_color); - datagram.add_be_int16(_relative_priority); - datagram.add_int8(_draw_type); - datagram.add_int8(_texwhite); - datagram.add_be_uint16(_color_name_index); - datagram.add_be_uint16(_alt_color_name_index); - datagram.pad_bytes(1); - datagram.add_int8(_billboard_type); - datagram.add_be_int16(_detail_texture_index); - datagram.add_be_int16(_texture_index); - datagram.add_be_int16(_material_index); - datagram.add_be_int16(_dfad_material_code); - datagram.add_be_int16(_dfad_feature_id); - datagram.add_be_int32(_ir_material_code); - datagram.add_be_uint16(_transparency); - datagram.add_uint8(_lod_generation_control); - datagram.add_uint8(_line_style_index); - datagram.add_be_uint32(_flags); - datagram.add_uint8(_light_mode); - datagram.pad_bytes(1 + 4); - datagram.pad_bytes(2); // Undocumented padding. - - if (!_packed_color.build_record(writer)) { - return false; - } - if (!_alt_packed_color.build_record(writer)) { - return false; - } - - datagram.add_be_int16(_texture_mapping_index); - datagram.pad_bytes(2); - datagram.add_be_uint32(_color_index); - datagram.add_be_uint32(_alt_color_index); - datagram.pad_bytes(2 + 2); return true; } diff --git a/pandatool/src/flt/fltFace.h b/pandatool/src/flt/fltFace.h index ce0ffcaa14..c43f708afc 100644 --- a/pandatool/src/flt/fltFace.h +++ b/pandatool/src/flt/fltFace.h @@ -8,96 +8,16 @@ #include -#include "fltBeadID.h" -#include "fltPackedColor.h" -#include "fltHeader.h" - -#include - -class FltTexture; -class FltMaterial; +#include "fltGeometry.h" //////////////////////////////////////////////////////////////////// // Class : FltFace // Description : A single face bead, e.g. a polygon. //////////////////////////////////////////////////////////////////// -class FltFace : public FltBeadID { +class FltFace : public FltGeometry { public: FltFace(FltHeader *header); - enum DrawType { - DT_solid_backface = 0, - DT_solid_no_backface = 1, - DT_wireframe = 2, - DT_wireframe_close = 3, - DT_wireframe_highlight = 4, - DT_omni_light = 5, - DT_uni_light = 6, - DT_bi_light = 7 - }; - - enum BillboardType { - BT_none = 0, - BT_fixed = 1, - BT_axial = 2, - BT_point = 4 - }; - - enum Flags { - F_terrain = 0x80000000, - F_no_color = 0x40000000, - F_no_alt_color = 0x20000000, - F_packed_color = 0x10000000, - F_terrain_footprint = 0x08000000, - F_hidden = 0x04000000 - }; - - enum LightMode { - LM_face_no_normal = 0, - LM_vertex_no_normal = 1, - LM_face_with_normal = 2, - LM_vertex_with_normal = 3 - }; - - int _ir_color; - int _relative_priority; - DrawType _draw_type; - bool _texwhite; - int _color_name_index; - int _alt_color_name_index; - BillboardType _billboard_type; - int _detail_texture_index; - int _texture_index; - int _material_index; - int _dfad_material_code; - int _dfad_feature_id; - int _ir_material_code; - int _transparency; - int _lod_generation_control; - int _line_style_index; - unsigned int _flags; - LightMode _light_mode; - FltPackedColor _packed_color; - FltPackedColor _alt_packed_color; - int _texture_mapping_index; - unsigned int _color_index; - unsigned int _alt_color_index; - -public: - INLINE bool has_texture() const; - INLINE FltTexture *get_texture() const; - - INLINE bool has_material() const; - INLINE FltMaterial *get_material() const; - - INLINE bool has_color() const; - Colorf get_color() const; - RGBColorf get_rgb() const; - - bool has_alt_color() const; - Colorf get_alt_color() const; - RGBColorf get_alt_rgb() const; - protected: virtual bool extract_record(FltRecordReader &reader); @@ -112,9 +32,9 @@ public: return _type_handle; } static void init_type() { - FltBeadID::init_type(); + FltGeometry::init_type(); register_type(_type_handle, "FltFace", - FltBeadID::get_class_type()); + FltGeometry::get_class_type()); } private: diff --git a/pandatool/src/flt/fltGeometry.I b/pandatool/src/flt/fltGeometry.I new file mode 100644 index 0000000000..0311e38c31 --- /dev/null +++ b/pandatool/src/flt/fltGeometry.I @@ -0,0 +1,60 @@ +// Filename: fltGeometry.I +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::has_texture +// Access: Public +// Description: Returns true if the face has a texture applied, false +// otherwise. +//////////////////////////////////////////////////////////////////// +INLINE bool FltGeometry:: +has_texture() const { + return (_texture_index >= 0 && _header->has_texture(_texture_index)); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::get_texture +// Access: Public +// Description: Returns the texture applied to this face, or NULL if +// no texture was applied. +//////////////////////////////////////////////////////////////////// +INLINE FltTexture *FltGeometry:: +get_texture() const { + return _header->get_texture(_texture_index); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::has_material +// Access: Public +// Description: Returns true if the face has a material applied, false +// otherwise. +//////////////////////////////////////////////////////////////////// +INLINE bool FltGeometry:: +has_material() const { + return (_material_index >= 0 && _header->has_material(_material_index)); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::get_material +// Access: Public +// Description: Returns the material applied to this face, or NULL if +// no material was applied. +//////////////////////////////////////////////////////////////////// +INLINE FltMaterial *FltGeometry:: +get_material() const { + return _header->get_material(_material_index); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::has_color +// Access: Public +// Description: Returns true if the face has a primary color +// indicated, false otherwise. +//////////////////////////////////////////////////////////////////// +INLINE bool FltGeometry:: +has_color() const { + return ((_flags & F_no_color) == 0) || has_material(); +} diff --git a/pandatool/src/flt/fltGeometry.cxx b/pandatool/src/flt/fltGeometry.cxx new file mode 100644 index 0000000000..67675b78b2 --- /dev/null +++ b/pandatool/src/flt/fltGeometry.cxx @@ -0,0 +1,239 @@ +// Filename: fltGeometry.cxx +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#include "fltGeometry.h" +#include "fltRecordReader.h" +#include "fltRecordWriter.h" +#include "fltHeader.h" +#include "fltMaterial.h" + +TypeHandle FltGeometry::_type_handle; + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +FltGeometry:: +FltGeometry(FltHeader *header) : FltBeadID(header) { + _ir_color = 0; + _relative_priority = 0; + _draw_type = DT_solid_backface; + _texwhite = false; + _color_name_index = 0; + _alt_color_name_index = 0; + _billboard_type = BT_none; + _detail_texture_index = -1; + _texture_index = -1; + _material_index = -1; + _dfad_material_code = 0; + _dfad_feature_id = 0; + _ir_material_code = 0; + _transparency = 0; + _lod_generation_control = 0; + _line_style_index = 0; + _flags = 0; + _light_mode = LM_face_no_normal; + _texture_mapping_index = 0; + _color_index = 0; + _alt_color_index = 0; +} + + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::get_color +// Access: Public +// Description: If has_color() indicates true, returns the primary +// color of the face, as a four-component value +// (including alpha as the transparency channel). +//////////////////////////////////////////////////////////////////// +Colorf FltGeometry:: +get_color() const { + nassertr(has_color(), Colorf(0.0, 0.0, 0.0, 0.0)); + + if (_texwhite && has_texture()) { + // Force this one white. + return Colorf(1.0, 1.0, 1.0, 1.0 - (_transparency / 65535.0)); + } + + if (has_material()) { + // If we have a material, that replaces the color. + FltMaterial *material = get_material(); + return Colorf(material->_diffuse[0], + material->_diffuse[1], + material->_diffuse[2], + 1.0 - (_transparency / 65535.0)); + } + + return _header->get_color(_color_index, (_flags & F_packed_color) != 0, + _packed_color, _transparency); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::get_rgb +// Access: Public +// Description: If has_color() indicates true, returns the primary +// color of the face, as a three-component value +// ignoring transparency. +//////////////////////////////////////////////////////////////////// +RGBColorf FltGeometry:: +get_rgb() const { + nassertr(has_color(), RGBColorf(0.0, 0.0, 0.0)); + + if (_texwhite && has_texture()) { + // Force this one white. + return RGBColorf(1.0, 1.0, 1.0); + } + + if (has_material()) { + // If we have a material, that replaces the color. + FltMaterial *material = get_material(); + return material->_diffuse; + } + + return _header->get_rgb(_color_index, (_flags & F_packed_color) != 0, + _packed_color); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::has_alt_color +// Access: Public +// Description: Returns true if the face has an alternate color +// indicated, false otherwise. +//////////////////////////////////////////////////////////////////// +bool FltGeometry:: +has_alt_color() const { + return (_flags & F_no_alt_color) == 0; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::get_alt_color +// Access: Public +// Description: If has_alt_color() indicates true, returns the alternate +// color of the face, as a four-component value +// (including alpha as the transparency channel). +//////////////////////////////////////////////////////////////////// +Colorf FltGeometry:: +get_alt_color() const { + nassertr(has_alt_color(), Colorf(0.0, 0.0, 0.0, 0.0)); + + return _header->get_color(_alt_color_index, (_flags & F_packed_color) != 0, + _alt_packed_color, _transparency); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::get_alt_rgb +// Access: Public +// Description: If has_alt_color() indicates true, returns the alternate +// color of the face, as a three-component value +// ignoring transparency. +//////////////////////////////////////////////////////////////////// +RGBColorf FltGeometry:: +get_alt_rgb() const { + nassertr(has_alt_color(), RGBColorf(0.0, 0.0, 0.0)); + + return _header->get_rgb(_alt_color_index, (_flags & F_packed_color) != 0, + _alt_packed_color); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::extract_record +// Access: Protected, Virtual +// Description: Fills in the information in this bead based on the +// information given in the indicated datagram, whose +// opcode has already been read. Returns true on +// success, false if the datagram is invalid. +//////////////////////////////////////////////////////////////////// +bool FltGeometry:: +extract_record(FltRecordReader &reader) { + DatagramIterator &iterator = reader.get_iterator(); + + _ir_color = iterator.get_be_int32(); + _relative_priority = iterator.get_be_int16(); + _draw_type = (DrawType)iterator.get_int8(); + _texwhite = (iterator.get_int8() != 0); + _color_name_index = iterator.get_be_int16(); + _alt_color_name_index = iterator.get_be_int16(); + iterator.skip_bytes(1); + _billboard_type = (BillboardType)iterator.get_int8(); + _detail_texture_index = iterator.get_be_int16(); + _texture_index = iterator.get_be_int16(); + _material_index = iterator.get_be_int16(); + _dfad_material_code = iterator.get_be_int16(); + _dfad_feature_id = iterator.get_be_int16(); + _ir_material_code = iterator.get_be_int32(); + _transparency = iterator.get_be_uint16(); + _lod_generation_control = iterator.get_uint8(); + _line_style_index = iterator.get_uint8(); + _flags = iterator.get_be_uint32(); + _light_mode = (LightMode)iterator.get_uint8(); + iterator.skip_bytes(1 + 4); + iterator.skip_bytes(2); // Undocumented padding. + + if (!_packed_color.extract_record(reader)) { + return false; + } + if (!_alt_packed_color.extract_record(reader)) { + return false; + } + + _texture_mapping_index = iterator.get_be_int16(); + iterator.skip_bytes(2); + _color_index = iterator.get_be_uint32(); + _alt_color_index = iterator.get_be_uint32(); + iterator.skip_bytes(2 + 2); + + return true; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltGeometry::build_record +// Access: Protected, Virtual +// Description: Fills up the current record on the FltRecordWriter with +// data for this record, but does not advance the +// writer. Returns true on success, false if there is +// some error. +//////////////////////////////////////////////////////////////////// +bool FltGeometry:: +build_record(FltRecordWriter &writer) const { + Datagram &datagram = writer.update_datagram(); + + datagram.add_be_int32(_ir_color); + datagram.add_be_int16(_relative_priority); + datagram.add_int8(_draw_type); + datagram.add_int8(_texwhite); + datagram.add_be_uint16(_color_name_index); + datagram.add_be_uint16(_alt_color_name_index); + datagram.pad_bytes(1); + datagram.add_int8(_billboard_type); + datagram.add_be_int16(_detail_texture_index); + datagram.add_be_int16(_texture_index); + datagram.add_be_int16(_material_index); + datagram.add_be_int16(_dfad_material_code); + datagram.add_be_int16(_dfad_feature_id); + datagram.add_be_int32(_ir_material_code); + datagram.add_be_uint16(_transparency); + datagram.add_uint8(_lod_generation_control); + datagram.add_uint8(_line_style_index); + datagram.add_be_uint32(_flags); + datagram.add_uint8(_light_mode); + datagram.pad_bytes(1 + 4); + datagram.pad_bytes(2); // Undocumented padding. + + if (!_packed_color.build_record(writer)) { + return false; + } + if (!_alt_packed_color.build_record(writer)) { + return false; + } + + datagram.add_be_int16(_texture_mapping_index); + datagram.pad_bytes(2); + datagram.add_be_uint32(_color_index); + datagram.add_be_uint32(_alt_color_index); + datagram.pad_bytes(2 + 2); + + return true; +} diff --git a/pandatool/src/flt/fltGeometry.h b/pandatool/src/flt/fltGeometry.h new file mode 100644 index 0000000000..c0bdf94c0b --- /dev/null +++ b/pandatool/src/flt/fltGeometry.h @@ -0,0 +1,131 @@ +// Filename: fltGeometry.h +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#ifndef FLTGEOMETRY_H +#define FLTGEOMETRY_H + +#include + +#include "fltBeadID.h" +#include "fltPackedColor.h" +#include "fltHeader.h" + +#include + +class FltTexture; +class FltMaterial; + +//////////////////////////////////////////////////////////////////// +// Class : FltGeometry +// Description : This is a base class for both FltFace and FltMesh, +// which are two different kinds of geometric primitives +// that might be encountered in a MultiGen file. They +// have similar properties. +//////////////////////////////////////////////////////////////////// +class FltGeometry : public FltBeadID { +public: + FltGeometry(FltHeader *header); + + enum DrawType { + DT_solid_backface = 0, + DT_solid_no_backface = 1, + DT_wireframe = 2, + DT_wireframe_close = 3, + DT_wireframe_highlight = 4, + DT_omni_light = 5, + DT_uni_light = 6, + DT_bi_light = 7 + }; + + enum BillboardType { + BT_none = 0, + BT_fixed = 1, + BT_axial = 2, + BT_point = 4 + }; + + enum Flags { + F_terrain = 0x80000000, + F_no_color = 0x40000000, + F_no_alt_color = 0x20000000, + F_packed_color = 0x10000000, + F_terrain_footprint = 0x08000000, + F_hidden = 0x04000000 + }; + + enum LightMode { + LM_face_no_normal = 0, + LM_vertex_no_normal = 1, + LM_face_with_normal = 2, + LM_vertex_with_normal = 3 + }; + + int _ir_color; + int _relative_priority; + DrawType _draw_type; + bool _texwhite; + int _color_name_index; + int _alt_color_name_index; + BillboardType _billboard_type; + int _detail_texture_index; + int _texture_index; + int _material_index; + int _dfad_material_code; + int _dfad_feature_id; + int _ir_material_code; + int _transparency; + int _lod_generation_control; + int _line_style_index; + unsigned int _flags; + LightMode _light_mode; + FltPackedColor _packed_color; + FltPackedColor _alt_packed_color; + int _texture_mapping_index; + unsigned int _color_index; + unsigned int _alt_color_index; + +public: + INLINE bool has_texture() const; + INLINE FltTexture *get_texture() const; + + INLINE bool has_material() const; + INLINE FltMaterial *get_material() const; + + INLINE bool has_color() const; + Colorf get_color() const; + RGBColorf get_rgb() const; + + bool has_alt_color() const; + Colorf get_alt_color() const; + RGBColorf get_alt_rgb() const; + + +protected: + virtual bool extract_record(FltRecordReader &reader); + virtual bool build_record(FltRecordWriter &writer) const; + +public: + virtual TypeHandle get_type() const { + return get_class_type(); + } + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + static TypeHandle get_class_type() { + return _type_handle; + } + static void init_type() { + FltBeadID::init_type(); + register_type(_type_handle, "FltGeometry", + FltBeadID::get_class_type()); + } + +private: + static TypeHandle _type_handle; +}; + +#include "fltGeometry.I" + +#endif + + diff --git a/pandatool/src/flt/fltGroup.cxx b/pandatool/src/flt/fltGroup.cxx index 4fa8d8220c..7a99f22dff 100644 --- a/pandatool/src/flt/fltGroup.cxx +++ b/pandatool/src/flt/fltGroup.cxx @@ -50,7 +50,7 @@ extract_record(FltRecordReader &reader) { _layer_id = iterator.get_int8(); iterator.skip_bytes(5); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltHeader.cxx b/pandatool/src/flt/fltHeader.cxx index 0bee30f49b..fde189104c 100644 --- a/pandatool/src/flt/fltHeader.cxx +++ b/pandatool/src/flt/fltHeader.cxx @@ -20,8 +20,8 @@ TypeHandle FltHeader::_type_handle; //////////////////////////////////////////////////////////////////// FltHeader:: FltHeader() : FltBeadID(this) { - _format_revision_level = 1520; - _edit_revision_level = 1520; + _format_revision_level = 1570; + _edit_revision_level = 1570; _next_group_id = 1; _next_lod_id = 1; _next_object_id = 1; @@ -57,6 +57,15 @@ FltHeader() : FltBeadID(this) { _next_cat_id = 1; _earth_model = EM_wgs84; + // New with 15.6 + _next_adaptive_id = 0; + _next_curve_id = 0; + + // New with 15.7 + _delta_z = 0.0; + _radius = 0.0; + _next_mesh_id = 0; + _vertex_lookups_stale = false; _current_vertex_offset = 0; _got_color_palette = false; @@ -239,15 +248,15 @@ min_flt_version() { //////////////////////////////////////////////////////////////////// double FltHeader:: max_flt_version() { - return 15.2; + return 15.7; } //////////////////////////////////////////////////////////////////// // Function: FltHeader::check_version // Access: Public // Description: Verifies that the version number read from the header -// is an understand version number, and prints a warning -// to the user if this is not so--the reading may or may +// is an understood version number, and prints a warning +// to the user if this is not so--the read may or may // not succeed. Returns true if the version number is // acceptable (and no warning is printed), or false if // it is questionable (and a warning is printed). @@ -593,7 +602,7 @@ get_closest_color(Colorf color) const { } //////////////////////////////////////////////////////////////////// -// Function: FltHeader::get_closest_color +// Function: FltHeader::get_closest_rgb // Access: Public // Description: Returns the color index of the nearest color in the // palette that matches the given three-component color, @@ -1144,10 +1153,26 @@ extract_record(FltRecordReader &reader) { iterator.skip_bytes(2 + 2 + 2 + 2); _earth_model = (EarthModel)iterator.get_be_int32(); - // Undocumented additional padding. + // Undocumented padding. iterator.skip_bytes(4); - // nassertr(iterator.get_remaining_size() == 0, true); + if (get_flt_version() >= 15.6 && iterator.get_remaining_size() > 0) { + _next_adaptive_id = iterator.get_be_int16(); + _next_curve_id = iterator.get_be_int16(); + iterator.skip_bytes(4); + + if (get_flt_version() >= 15.7 && iterator.get_remaining_size() > 0) { + _delta_z = iterator.get_be_float64(); + _radius = iterator.get_be_float64(); + _next_mesh_id = iterator.get_be_int16(); + iterator.skip_bytes(2); + + // Undocumented padding. + iterator.skip_bytes(4); + } + } + + check_remaining_size(iterator); return true; } @@ -1260,8 +1285,23 @@ build_record(FltRecordWriter &writer) const { datagram.pad_bytes(2 + 2 + 2 + 2); datagram.add_be_int32(_earth_model); - // Undocumented additional padding. - datagram.pad_bytes(4); + datagram.pad_bytes(4); + + if (get_flt_version() >= 15.6) { + // New with 15.6 + datagram.add_be_int16(_next_adaptive_id); + datagram.add_be_int16(_next_curve_id); + datagram.pad_bytes(4); + + if (get_flt_version() >= 15.7) { + // New with 15.7 + datagram.add_be_float64(_delta_z); + datagram.add_be_float64(_radius); + datagram.add_be_int16(_next_mesh_id); + datagram.pad_bytes(2); + datagram.pad_bytes(4); + } + } return true; } @@ -1377,7 +1417,7 @@ extract_color_palette(FltRecordReader &reader) { _color_names[color_index] = iterator.get_fixed_string(name_length); } - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } @@ -1479,7 +1519,7 @@ extract_eyepoint_palette(FltRecordReader &reader) { } _got_eyepoint_trackplane_palette = true; - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltHeader.h b/pandatool/src/flt/fltHeader.h index d4cc4a0bbf..5c0f6480d4 100644 --- a/pandatool/src/flt/fltHeader.h +++ b/pandatool/src/flt/fltHeader.h @@ -120,6 +120,11 @@ public: int _next_road_id; int _next_cat_id; EarthModel _earth_model; + int _next_adaptive_id; + int _next_curve_id; + double _delta_z; + double _radius; + int _next_mesh_id; public: double get_flt_version() const; diff --git a/pandatool/src/flt/fltInstanceDefinition.cxx b/pandatool/src/flt/fltInstanceDefinition.cxx index 45506b8684..856b9e767b 100644 --- a/pandatool/src/flt/fltInstanceDefinition.cxx +++ b/pandatool/src/flt/fltInstanceDefinition.cxx @@ -39,7 +39,7 @@ extract_record(FltRecordReader &reader) { iterator.skip_bytes(2); _instance_index = iterator.get_be_int16(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltInstanceRef.cxx b/pandatool/src/flt/fltInstanceRef.cxx index 100adc0744..8d10a7df95 100644 --- a/pandatool/src/flt/fltInstanceRef.cxx +++ b/pandatool/src/flt/fltInstanceRef.cxx @@ -61,7 +61,7 @@ extract_record(FltRecordReader &reader) { iterator.skip_bytes(2); _instance_index = iterator.get_be_int16(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltLOD.cxx b/pandatool/src/flt/fltLOD.cxx index 4a3bc6dc4c..cc3e0f44ee 100644 --- a/pandatool/src/flt/fltLOD.cxx +++ b/pandatool/src/flt/fltLOD.cxx @@ -55,7 +55,7 @@ extract_record(FltRecordReader &reader) { _center_z = iterator.get_be_float64(); _transition_range = iterator.get_be_float64(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltLightSourceDefinition.cxx b/pandatool/src/flt/fltLightSourceDefinition.cxx index ab91d996f8..e14c698c33 100644 --- a/pandatool/src/flt/fltLightSourceDefinition.cxx +++ b/pandatool/src/flt/fltLightSourceDefinition.cxx @@ -76,7 +76,7 @@ extract_record(FltRecordReader &reader) { _modeling_light = (iterator.get_be_int32() != 0); iterator.skip_bytes(4*19); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltLocalVertexPool.I b/pandatool/src/flt/fltLocalVertexPool.I new file mode 100644 index 0000000000..695cb1a299 --- /dev/null +++ b/pandatool/src/flt/fltLocalVertexPool.I @@ -0,0 +1,4 @@ +// Filename: fltLocalVertexPool.I +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// diff --git a/pandatool/src/flt/fltLocalVertexPool.cxx b/pandatool/src/flt/fltLocalVertexPool.cxx new file mode 100644 index 0000000000..75a758103b --- /dev/null +++ b/pandatool/src/flt/fltLocalVertexPool.cxx @@ -0,0 +1,235 @@ +// Filename: fltLocalVertexPool.cxx +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#include "fltLocalVertexPool.h" +#include "fltRecordReader.h" +#include "fltRecordWriter.h" +#include "fltHeader.h" +#include "fltMaterial.h" + +TypeHandle FltLocalVertexPool::_type_handle; + +//////////////////////////////////////////////////////////////////// +// Function: FltLocalVertexPool::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +FltLocalVertexPool:: +FltLocalVertexPool(FltHeader *header) : FltRecord(header) { +} + +//////////////////////////////////////////////////////////////////// +// Function: FltLocalVertexPool::extract_record +// Access: Protected, Virtual +// Description: Fills in the information in this bead based on the +// information given in the indicated datagram, whose +// opcode has already been read. Returns true on +// success, false if the datagram is invalid. +//////////////////////////////////////////////////////////////////// +bool FltLocalVertexPool:: +extract_record(FltRecordReader &reader) { + if (!FltRecord::extract_record(reader)) { + return false; + } + + nassertr(reader.get_opcode() == FO_local_vertex_pool, false); + DatagramIterator &iterator = reader.get_iterator(); + + int num_vertices = iterator.get_be_int32(); + int attributes = iterator.get_be_int32(); + + for (int i = 0; i < num_vertices; i++) { + FltVertex *vertex = new FltVertex(_header); + _vertices.push_back(vertex); + + if ((attributes & AM_has_position) != 0) { + vertex->_pos[0] = iterator.get_be_float64(); + vertex->_pos[1] = iterator.get_be_float64(); + vertex->_pos[2] = iterator.get_be_float64(); + } + + if ((attributes & AM_has_color_index) != 0) { + vertex->_color_index = iterator.get_be_int32(); + + } else if ((attributes & AM_has_packed_color) != 0) { + if (!vertex->_packed_color.extract_record(reader)) { + return false; + } + vertex->_flags |= FltVertex::F_packed_color; + + } else { + vertex->_flags |= FltVertex::F_no_color; + } + + if ((attributes & AM_has_normal) != 0) { + vertex->_normal[0] = iterator.get_be_float32(); + vertex->_normal[1] = iterator.get_be_float32(); + vertex->_normal[2] = iterator.get_be_float32(); + vertex->_has_normal = true; + } + + if ((attributes & AM_has_base_uv) != 0) { + vertex->_uv[0] = iterator.get_be_float32(); + vertex->_uv[1] = iterator.get_be_float32(); + vertex->_has_uv = true; + } + + if ((attributes & AM_has_uv_1) != 0) { + iterator.get_be_float32(); + iterator.get_be_float32(); + } + + if ((attributes & AM_has_uv_2) != 0) { + iterator.get_be_float32(); + iterator.get_be_float32(); + } + + if ((attributes & AM_has_uv_3) != 0) { + iterator.get_be_float32(); + iterator.get_be_float32(); + } + + if ((attributes & AM_has_uv_4) != 0) { + iterator.get_be_float32(); + iterator.get_be_float32(); + } + + if ((attributes & AM_has_uv_5) != 0) { + iterator.get_be_float32(); + iterator.get_be_float32(); + } + + if ((attributes & AM_has_uv_6) != 0) { + iterator.get_be_float32(); + iterator.get_be_float32(); + } + + if ((attributes & AM_has_uv_7) != 0) { + iterator.get_be_float32(); + iterator.get_be_float32(); + } + } + + check_remaining_size(iterator); + return true; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltLocalVertexPool::build_record +// Access: Protected, Virtual +// Description: Fills up the current record on the FltRecordWriter with +// data for this record, but does not advance the +// writer. Returns true on success, false if there is +// some error. +//////////////////////////////////////////////////////////////////// +bool FltLocalVertexPool:: +build_record(FltRecordWriter &writer) const { + if (!FltRecord::build_record(writer)) { + return false; + } + + writer.set_opcode(FO_local_vertex_pool); + Datagram &datagram = writer.update_datagram(); + + // Determine what kind of vertices we have. + int attributes = AM_has_position; + + Vertices::const_iterator vi; + for (vi = _vertices.begin(); vi != _vertices.end(); ++vi) { + FltVertex *vertex = (*vi); + if ((vertex->_flags & FltVertex::F_no_color) != 0) { + // No color. + + } else if ((vertex->_flags & FltVertex::F_packed_color) != 0) { + // Packed color. + attributes |= AM_has_packed_color; + + } else { + // Indexed color. + attributes |= AM_has_color_index; + } + + if (vertex->_has_normal) { + attributes |= AM_has_normal; + } + + if (vertex->_has_uv) { + attributes |= AM_has_base_uv; + } + } + + if ((attributes & AM_has_packed_color) != 0 && + (attributes & AM_has_color_index) != 0) { + // We cannot have both a packed color and a color index. If we + // want both, used packed color. + attributes &= ~AM_has_color_index; + } + + datagram.add_be_int32(_vertices.size()); + datagram.add_be_int32(attributes); + + // Now write out each vertex. + for (vi = _vertices.begin(); vi != _vertices.end(); ++vi) { + FltVertex *vertex = (*vi); + + if ((attributes & AM_has_position) != 0) { + datagram.add_be_float64(vertex->_pos[0]); + datagram.add_be_float64(vertex->_pos[1]); + datagram.add_be_float64(vertex->_pos[2]); + } + + if ((attributes & AM_has_color_index) != 0) { + if ((vertex->_flags & (FltVertex::F_no_color | FltVertex::F_packed_color)) != 0) { + // This particular vertex does not have a color index. + // Make it white. + datagram.add_be_int32(_header->get_closest_rgb(RGBColorf(1.0, 1.0, 1.0))); + } else { + datagram.add_be_int32(vertex->_color_index); + } + + } else if ((attributes & AM_has_packed_color) != 0) { + // We extract our own FltPackedColor instead of writing out the + // vertex's _packed_color directly, just in case the vertex is + // actually index colored. This bit of code will work + // regardless of the kind of color the vertex has. + + FltPackedColor color; + if (vertex->has_color()) { + color.set_color(vertex->get_color()); + } else { + // An uncolored vertex. Make it white. + color.set_color(Colorf(1.0, 1.0, 1.0, 1.0)); + } + + if (!color.build_record(writer)) { + return false; + } + } + + if ((attributes & AM_has_normal) != 0) { + if (!vertex->_has_normal) { + datagram.add_be_float32(0.0); + datagram.add_be_float32(0.0); + datagram.add_be_float32(0.0); + } else { + datagram.add_be_float32(vertex->_normal[0]); + datagram.add_be_float32(vertex->_normal[1]); + datagram.add_be_float32(vertex->_normal[2]); + } + } + + if ((attributes & AM_has_base_uv) != 0) { + if (!vertex->_has_uv) { + datagram.add_be_float32(0.0); + datagram.add_be_float32(0.0); + } else { + datagram.add_be_float32(vertex->_uv[0]); + datagram.add_be_float32(vertex->_uv[1]); + } + } + } + + return true; +} diff --git a/pandatool/src/flt/fltLocalVertexPool.h b/pandatool/src/flt/fltLocalVertexPool.h new file mode 100644 index 0000000000..aa4ea86940 --- /dev/null +++ b/pandatool/src/flt/fltLocalVertexPool.h @@ -0,0 +1,72 @@ +// Filename: fltLocalVertexPool.h +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#ifndef FLTLOCALVERTEXPOOL_H +#define FLTLOCALVERTEXPOOL_H + +#include + +#include "fltRecord.h" +#include "fltHeader.h" +#include "fltVertex.h" + +#include + +//////////////////////////////////////////////////////////////////// +// Class : FltLocalVertexPool +// Description : A local vertex pool, as might appear in the middle of +// the hierarchy, for instance for a mesh. +//////////////////////////////////////////////////////////////////// +class FltLocalVertexPool : public FltRecord { +public: + FltLocalVertexPool(FltHeader *header); + + // These bits are not stored in the vertex pool, but are read from + // the .flt file and used immediately. + enum AttributeMask { + AM_has_position = 0x80000000, + AM_has_color_index = 0x40000000, + AM_has_packed_color = 0x20000000, + AM_has_normal = 0x10000000, + AM_has_base_uv = 0x08000000, + AM_has_uv_1 = 0x04000000, + AM_has_uv_2 = 0x02000000, + AM_has_uv_3 = 0x01000000, + AM_has_uv_4 = 0x00800000, + AM_has_uv_5 = 0x00400000, + AM_has_uv_6 = 0x00200000, + AM_has_uv_7 = 0x00100000 + }; + + typedef vector Vertices; + Vertices _vertices; + +public: + virtual bool extract_record(FltRecordReader &reader); + virtual bool build_record(FltRecordWriter &writer) const; + +public: + virtual TypeHandle get_type() const { + return get_class_type(); + } + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + static TypeHandle get_class_type() { + return _type_handle; + } + static void init_type() { + FltRecord::init_type(); + register_type(_type_handle, "FltLocalVertexPool", + FltRecord::get_class_type()); + } + +private: + static TypeHandle _type_handle; +}; + +#include "fltLocalVertexPool.I" + +#endif + + diff --git a/pandatool/src/flt/fltMaterial.cxx b/pandatool/src/flt/fltMaterial.cxx index 81a7bdb170..285021abf3 100644 --- a/pandatool/src/flt/fltMaterial.cxx +++ b/pandatool/src/flt/fltMaterial.cxx @@ -62,7 +62,7 @@ extract_record(FltRecordReader &reader) { _alpha = iterator.get_be_float32(); iterator.skip_bytes(4); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltMesh.I b/pandatool/src/flt/fltMesh.I new file mode 100644 index 0000000000..6dcdea8750 --- /dev/null +++ b/pandatool/src/flt/fltMesh.I @@ -0,0 +1,4 @@ +// Filename: fltMesh.I +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// diff --git a/pandatool/src/flt/fltMesh.cxx b/pandatool/src/flt/fltMesh.cxx new file mode 100644 index 0000000000..5b3f932639 --- /dev/null +++ b/pandatool/src/flt/fltMesh.cxx @@ -0,0 +1,118 @@ +// Filename: fltMesh.cxx +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#include "fltMesh.h" +#include "fltRecordReader.h" +#include "fltRecordWriter.h" +#include "fltHeader.h" +#include "fltMaterial.h" +#include "config_flt.h" + +TypeHandle FltMesh::_type_handle; + +//////////////////////////////////////////////////////////////////// +// Function: FltMesh::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +FltMesh:: +FltMesh(FltHeader *header) : FltGeometry(header) { +} + +//////////////////////////////////////////////////////////////////// +// Function: FltMesh::extract_record +// Access: Protected, Virtual +// Description: Fills in the information in this bead based on the +// information given in the indicated datagram, whose +// opcode has already been read. Returns true on +// success, false if the datagram is invalid. +//////////////////////////////////////////////////////////////////// +bool FltMesh:: +extract_record(FltRecordReader &reader) { + if (!FltBeadID::extract_record(reader)) { + return false; + } + + DatagramIterator &iterator = reader.get_iterator(); + iterator.skip_bytes(4); // Undocumented padding. + + if (!FltGeometry::extract_record(reader)) { + return false; + } + + nassertr(reader.get_opcode() == FO_mesh, false); + + check_remaining_size(iterator); + return true; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltMesh::extract_ancillary +// Access: Protected, Virtual +// Description: Checks whether the given bead, which follows this +// bead sequentially in the file, is an ancillary record +// of this bead. If it is, extracts the relevant +// information and returns true; otherwise, leaves it +// alone and returns false. +//////////////////////////////////////////////////////////////////// +bool FltMesh:: +extract_ancillary(FltRecordReader &reader) { + if (reader.get_opcode() == FO_local_vertex_pool) { + _vpool = new FltLocalVertexPool(_header); + return _vpool->extract_record(reader); + } + + return FltBeadID::extract_ancillary(reader); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltMesh::build_record +// Access: Protected, Virtual +// Description: Fills up the current record on the FltRecordWriter with +// data for this record, but does not advance the +// writer. Returns true on success, false if there is +// some error. +//////////////////////////////////////////////////////////////////// +bool FltMesh:: +build_record(FltRecordWriter &writer) const { + if (!FltBeadID::build_record(writer)) { + return false; + } + + Datagram &datagram = writer.update_datagram(); + datagram.pad_bytes(4); // Undocumented padding. + + if (!FltGeometry::build_record(writer)) { + return false; + } + + writer.set_opcode(FO_mesh); + + return true; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltMesh::write_ancillary +// Access: Protected, Virtual +// Description: Writes whatever ancillary records are required for +// this record. Returns FE_ok on success, or something +// else if there is some error. +//////////////////////////////////////////////////////////////////// +FltError FltMesh:: +write_ancillary(FltRecordWriter &writer) const { + if (_vpool != (FltLocalVertexPool *)NULL) { + if (!_vpool->build_record(writer)) { + assert(!flt_error_abort); + return FE_bad_data; + } + FltError result = writer.advance(); + if (result != FE_ok) { + return result; + } + } + + return FltBeadID::write_ancillary(writer); +} + diff --git a/pandatool/src/flt/fltMesh.h b/pandatool/src/flt/fltMesh.h new file mode 100644 index 0000000000..2ee9886951 --- /dev/null +++ b/pandatool/src/flt/fltMesh.h @@ -0,0 +1,56 @@ +// Filename: fltMesh.h +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#ifndef FLTMESH_H +#define FLTMESH_H + +#include + +#include "fltGeometry.h" +#include "fltLocalVertexPool.h" + +#include + +//////////////////////////////////////////////////////////////////// +// Class : FltMesh +// Description : A mesh of connected polygons and tristrips, etc., +// with a local vertex pool. +//////////////////////////////////////////////////////////////////// +class FltMesh : public FltGeometry { +public: + FltMesh(FltHeader *header); + + PT(FltLocalVertexPool) _vpool; + +protected: + virtual bool extract_record(FltRecordReader &reader); + virtual bool extract_ancillary(FltRecordReader &reader); + + virtual bool build_record(FltRecordWriter &writer) const; + virtual FltError write_ancillary(FltRecordWriter &writer) const; + +public: + virtual TypeHandle get_type() const { + return get_class_type(); + } + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + static TypeHandle get_class_type() { + return _type_handle; + } + static void init_type() { + FltGeometry::init_type(); + register_type(_type_handle, "FltMesh", + FltGeometry::get_class_type()); + } + +private: + static TypeHandle _type_handle; +}; + +#include "fltMesh.I" + +#endif + + diff --git a/pandatool/src/flt/fltMeshPrimitive.I b/pandatool/src/flt/fltMeshPrimitive.I new file mode 100644 index 0000000000..f3a8f930e6 --- /dev/null +++ b/pandatool/src/flt/fltMeshPrimitive.I @@ -0,0 +1,4 @@ +// Filename: fltMeshPrimitive.I +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// diff --git a/pandatool/src/flt/fltMeshPrimitive.cxx b/pandatool/src/flt/fltMeshPrimitive.cxx new file mode 100644 index 0000000000..5409138045 --- /dev/null +++ b/pandatool/src/flt/fltMeshPrimitive.cxx @@ -0,0 +1,127 @@ +// Filename: fltMeshPrimitive.cxx +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#include "fltMeshPrimitive.h" +#include "fltRecordReader.h" +#include "fltRecordWriter.h" +#include "fltHeader.h" +#include "fltMaterial.h" + +TypeHandle FltMeshPrimitive::_type_handle; + +//////////////////////////////////////////////////////////////////// +// Function: FltMeshPrimitive::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +FltMeshPrimitive:: +FltMeshPrimitive(FltHeader *header) : FltBead(header) { + _primitive_type = PT_tristrip; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltMeshPrimitive::extract_record +// Access: Protected, Virtual +// Description: Fills in the information in this bead based on the +// information given in the indicated datagram, whose +// opcode has already been read. Returns true on +// success, false if the datagram is invalid. +//////////////////////////////////////////////////////////////////// +bool FltMeshPrimitive:: +extract_record(FltRecordReader &reader) { + if (!FltBead::extract_record(reader)) { + return false; + } + + nassertr(reader.get_opcode() == FO_mesh_primitive, false); + DatagramIterator &iterator = reader.get_iterator(); + + _primitive_type = (PrimitiveType)iterator.get_be_int16(); + + int vertex_width = iterator.get_be_int16(); + int num_vertices = iterator.get_be_int32(); + + if (vertex_width == 1) { + for (int i = 0; i < num_vertices; i++) { + _vertices.push_back(iterator.get_uint8()); + } + + } else if (vertex_width == 2) { + for (int i = 0; i < num_vertices; i++) { + _vertices.push_back(iterator.get_be_uint16()); + } + + } else if (vertex_width == 4) { + for (int i = 0; i < num_vertices; i++) { + _vertices.push_back(iterator.get_be_int32()); + } + + } else { + nout << "Invalid vertex width in mesh primitive: " << vertex_width + << "\n"; + return false; + } + + check_remaining_size(iterator); + return true; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltMeshPrimitive::build_record +// Access: Protected, Virtual +// Description: Fills up the current record on the FltRecordWriter with +// data for this record, but does not advance the +// writer. Returns true on success, false if there is +// some error. +//////////////////////////////////////////////////////////////////// +bool FltMeshPrimitive:: +build_record(FltRecordWriter &writer) const { + if (!FltBead::build_record(writer)) { + return false; + } + + writer.set_opcode(FO_mesh_primitive); + Datagram &datagram = writer.update_datagram(); + + datagram.add_be_int16(_primitive_type); + + // Determine the optimum index width, based on the largest vertex + // index. + int max_index = 0; + Vertices::const_iterator vi; + for (vi = _vertices.begin(); vi != _vertices.end(); ++vi) { + max_index = max(max_index, (*vi)); + } + + int vertex_width; + if (max_index < 0x100) { + vertex_width = 1; + } else if (max_index < 0x10000) { + vertex_width = 2; + } else { + vertex_width = 4; + } + + datagram.add_be_int16(vertex_width); + datagram.add_be_int32(_vertices.size()); + + if (vertex_width == 1) { + for (vi = _vertices.begin(); vi != _vertices.end(); ++vi) { + datagram.add_uint8(*vi); + } + + } else if (vertex_width == 2) { + for (vi = _vertices.begin(); vi != _vertices.end(); ++vi) { + datagram.add_be_uint16(*vi); + } + + } else { + for (vi = _vertices.begin(); vi != _vertices.end(); ++vi) { + datagram.add_be_int32(*vi); + } + } + + return true; +} diff --git a/pandatool/src/flt/fltMeshPrimitive.h b/pandatool/src/flt/fltMeshPrimitive.h new file mode 100644 index 0000000000..dd6b181e5c --- /dev/null +++ b/pandatool/src/flt/fltMeshPrimitive.h @@ -0,0 +1,64 @@ +// Filename: fltMeshPrimitive.h +// Created by: drose (28Feb01) +// +//////////////////////////////////////////////////////////////////// + +#ifndef FLTMESHPRIMITIVE_H +#define FLTMESHPRIMITIVE_H + +#include + +#include "fltBead.h" +#include "fltHeader.h" + +#include + +//////////////////////////////////////////////////////////////////// +// Class : FltMeshPrimitive +// Description : A single primitive of a mesh, like a triangle strip +// or fan. +//////////////////////////////////////////////////////////////////// +class FltMeshPrimitive : public FltBead { +public: + FltMeshPrimitive(FltHeader *header); + + enum PrimitiveType { + PT_tristrip = 1, + PT_trifan = 2, + PT_quadstrip = 3, + PT_polygon = 4, + }; + + typedef vector Vertices; + + PrimitiveType _primitive_type; + Vertices _vertices; + + +protected: + virtual bool extract_record(FltRecordReader &reader); + virtual bool build_record(FltRecordWriter &writer) const; + +public: + virtual TypeHandle get_type() const { + return get_class_type(); + } + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + static TypeHandle get_class_type() { + return _type_handle; + } + static void init_type() { + FltBead::init_type(); + register_type(_type_handle, "FltMeshPrimitive", + FltBead::get_class_type()); + } + +private: + static TypeHandle _type_handle; +}; + +#include "fltMeshPrimitive.I" + +#endif + + diff --git a/pandatool/src/flt/fltObject.cxx b/pandatool/src/flt/fltObject.cxx index 1056845daa..c47bf57e27 100644 --- a/pandatool/src/flt/fltObject.cxx +++ b/pandatool/src/flt/fltObject.cxx @@ -43,7 +43,7 @@ extract_record(FltRecordReader &reader) { _significance = iterator.get_be_int16(); iterator.skip_bytes(2); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltOpcode.cxx b/pandatool/src/flt/fltOpcode.cxx index c963d7492e..f4861a7a1b 100644 --- a/pandatool/src/flt/fltOpcode.cxx +++ b/pandatool/src/flt/fltOpcode.cxx @@ -69,6 +69,15 @@ operator << (ostream &out, FltOpcode opcode) { case FO_pop_face: return out << "pop subface"; + case FO_push_extension: + return out << "push extension"; + + case FO_pop_extension: + return out << "pop extension"; + + case FO_continuation: + return out << "continuation"; + case FO_comment: return out << "comment"; @@ -103,6 +112,12 @@ operator << (ostream &out, FltOpcode opcode) { case FO_vector: return out << "vector"; + case FO_multitexture: + return out << "multitexture"; + + case FO_uv_list: + return out << "UV list"; + case FO_bsp: return out << "BSP"; @@ -172,6 +187,15 @@ operator << (ostream &out, FltOpcode opcode) { case FO_eyepoint_palette: return out << "eyepoint palette"; + case FO_mesh: + return out << "mesh"; + + case FO_local_vertex_pool: + return out << "local vertex pool"; + + case FO_mesh_primitive: + return out << "mesh primitive"; + case FO_road_segment: return out << "road segment"; @@ -226,14 +250,17 @@ operator << (ostream &out, FltOpcode opcode) { case FO_bv_orientation: return out << "bounding volume orientation"; + case FO_light_point: + return out << "light point"; + case FO_texture_map_palette: return out << "texture mapping palette"; case FO_15_material: return out << "material"; - case FO_color_name_palette: - return out << "color name palette"; + case FO_name_table: + return out << "name table"; case FO_cat: return out << "continuously adaptive terrain"; @@ -247,6 +274,15 @@ operator << (ostream &out, FltOpcode opcode) { case FO_pop_attribute: return out << "pop attribute"; + case FO_adaptive_attribute: + return out << "adaptive attribute"; + + case FO_curve: + return out << "curve"; + + case FO_road_construction: + return out << "road construction"; + default: return out << "unknown opcode " << (int)opcode; } diff --git a/pandatool/src/flt/fltOpcode.h b/pandatool/src/flt/fltOpcode.h index c475367655..38637cba26 100644 --- a/pandatool/src/flt/fltOpcode.h +++ b/pandatool/src/flt/fltOpcode.h @@ -29,6 +29,10 @@ enum FltOpcode { FO_OB_instance = 17, // obsolete FO_push_face = 19, FO_pop_face = 20, + FO_push_extension = 21, + FO_pop_extension = 22, + FO_continuation = 23, + FO_comment = 31, FO_color_palette = 32, FO_long_id = 33, @@ -44,6 +48,8 @@ enum FltOpcode { FO_transform_matrix = 49, FO_vector = 50, FO_OB_bounding_box = 51, // obsolete + FO_multitexture = 52, + FO_uv_list = 53, FO_bsp = 55, FO_replicate = 60, FO_instance_ref = 61, @@ -68,6 +74,9 @@ enum FltOpcode { FO_rotate_and_scale = 81, FO_put = 82, FO_eyepoint_palette = 83, + FO_mesh = 84, + FO_local_vertex_pool = 85, + FO_mesh_primitive = 86, FO_road_segment = 87, FO_road_zone = 88, FO_morph_list = 89, @@ -80,19 +89,24 @@ enum FltOpcode { FO_switch = 96, FO_line_style = 97, FO_clip_region = 98, + FO_extension = 100, FO_light_source = 101, FO_light_definition = 102, FO_bounding_sphere = 105, FO_bounding_cylinder = 106, FO_bv_center = 108, FO_bv_orientation = 109, + FO_light_point = 111, FO_texture_map_palette = 112, FO_15_material = 113, - FO_color_name_palette = 114, + FO_name_table = 114, FO_cat = 115, FO_cat_data = 116, FO_push_attribute = 122, FO_pop_attribute = 123, + FO_adaptive_attribute = 125, + FO_curve = 126, + FO_road_construction = 127 }; ostream &operator << (ostream &out, FltOpcode opcode); diff --git a/pandatool/src/flt/fltPackedColor.I b/pandatool/src/flt/fltPackedColor.I index 74f636551a..206133c730 100644 --- a/pandatool/src/flt/fltPackedColor.I +++ b/pandatool/src/flt/fltPackedColor.I @@ -45,3 +45,32 @@ INLINE RGBColorf FltPackedColor:: get_rgb() const { return RGBColorf(_r / 255.0, _g / 255.0, _b / 255.0); } + +//////////////////////////////////////////////////////////////////// +// Function: FltPackedColor::set_color +// Access: Public +// Description: Sets the color according to the indicated +// four-component Colorf value (including alpha). +//////////////////////////////////////////////////////////////////// +INLINE void FltPackedColor:: +set_color(const Colorf &color) { + _r = (int)floor(color[0] * 255.0); + _g = (int)floor(color[0] * 255.0); + _b = (int)floor(color[0] * 255.0); + _a = (int)floor(color[0] * 255.0); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltPackedColor::set_rgb +// Access: Public +// Description: Sets the color according to the indicated +// three-component RGBColorf value, and set the alpha to +// 1.0. +//////////////////////////////////////////////////////////////////// +INLINE void FltPackedColor:: +set_rgb(const RGBColorf &color) { + _r = (int)floor(color[0] * 255.0); + _g = (int)floor(color[0] * 255.0); + _b = (int)floor(color[0] * 255.0); + _a = 255; +} diff --git a/pandatool/src/flt/fltPackedColor.h b/pandatool/src/flt/fltPackedColor.h index c28ea783f8..63e7543cd5 100644 --- a/pandatool/src/flt/fltPackedColor.h +++ b/pandatool/src/flt/fltPackedColor.h @@ -9,6 +9,7 @@ #include #include +#include class FltRecordReader; class FltRecordWriter; @@ -24,6 +25,8 @@ public: INLINE Colorf get_color() const; INLINE RGBColorf get_rgb() const; + INLINE void set_color(const Colorf &color); + INLINE void set_rgb(const RGBColorf &rgb); void output(ostream &out) const; bool extract_record(FltRecordReader &reader); diff --git a/pandatool/src/flt/fltRecord.cxx b/pandatool/src/flt/fltRecord.cxx index d033c595a7..6c016f8826 100644 --- a/pandatool/src/flt/fltRecord.cxx +++ b/pandatool/src/flt/fltRecord.cxx @@ -10,6 +10,10 @@ #include "fltGroup.h" #include "fltObject.h" #include "fltFace.h" +#include "fltCurve.h" +#include "fltMesh.h" +#include "fltLocalVertexPool.h" +#include "fltMeshPrimitive.h" #include "fltVertexList.h" #include "fltLOD.h" #include "fltInstanceDefinition.h" @@ -19,6 +23,7 @@ #include "config_flt.h" #include +#include #include @@ -132,6 +137,52 @@ add_subface(FltRecord *subface) { _subfaces.push_back(subface); } +//////////////////////////////////////////////////////////////////// +// Function: FltRecord::get_num_extensions +// Access: Public +// Description: Returns the number of extension attribute records for +// this object. These are auxiliary nodes, presumably +// of type FO_extension, that have some local meaning to +// the object. +//////////////////////////////////////////////////////////////////// +int FltRecord:: +get_num_extensions() const { + return _extensions.size(); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltRecord::get_extension +// Access: Public +// Description: Returns the nth extension of this record. +//////////////////////////////////////////////////////////////////// +FltRecord *FltRecord:: +get_extension(int n) const { + nassertr(n >= 0 && n < (int)_extensions.size(), (FltRecord *)NULL); + return _extensions[n]; +} + +//////////////////////////////////////////////////////////////////// +// Function: FltRecord::clear_extensions +// Access: Public +// Description: Removes all extensions from this record. +//////////////////////////////////////////////////////////////////// +void FltRecord:: +clear_extensions() { + _extensions.clear(); +} + +//////////////////////////////////////////////////////////////////// +// Function: FltRecord::add_extension +// Access: Public +// Description: Adds a new extension to the end of the list of +// extensions for this record. This should be a record +// of type FO_extension. +//////////////////////////////////////////////////////////////////// +void FltRecord:: +add_extension(FltRecord *extension) { + _extensions.push_back(extension); +} + //////////////////////////////////////////////////////////////////// // Function: FltRecord::get_num_ancillary // Access: Public @@ -233,6 +284,31 @@ set_comment(const string &comment) { _comment = comment; } +//////////////////////////////////////////////////////////////////// +// Function: FltRecord::check_remaining_size +// Access: Public +// Description: Checks that the iterator has no bytes left, as it +// should at the end of a successfully read record. If +// there *are* remaining bytes, print a warning message +// but otherwise don't worry about it. +// +// If we are attempting to read a flt file whose version +// is newer than the newest this program understands, +// don't even print a warning message, since this is +// exactly the sort of thing we expect. +//////////////////////////////////////////////////////////////////// +void FltRecord:: +check_remaining_size(const DatagramIterator &iterator) const { + if (iterator.get_remaining_size() == 0) { + return; + } + + if (_header->get_flt_version() <= _header->max_flt_version()) { + nout << "Warning! Ignoring extra " << iterator.get_remaining_size() + << " bytes at the end of a " << get_type() << " record.\n"; + } +} + //////////////////////////////////////////////////////////////////// // Function: FltRecord::output // Access: Public @@ -272,6 +348,9 @@ write_children(ostream &out, int indent_level) const { if (!_ancillary.empty()) { out << " + " << _ancillary.size() << " ancillary"; } + if (!_extensions.empty()) { + out << " + " << _extensions.size() << " extensions"; + } if (!_subfaces.empty()) { out << " ["; Records::const_iterator ci; @@ -313,6 +392,8 @@ is_ancillary(FltOpcode opcode) { switch (opcode) { case FO_comment: case FO_long_id: + case FO_multitexture: + case FO_uv_list: case FO_replicate: case FO_road_zone: case FO_transform_matrix: @@ -329,13 +410,16 @@ is_ancillary(FltOpcode opcode) { case FO_bounding_cylinder: case FO_bv_center: case FO_bv_orientation: + case FO_local_vertex_pool: + case FO_cat_data: + case FO_vertex_palette: case FO_vertex_c: case FO_vertex_cn: case FO_vertex_cnu: case FO_vertex_cu: case FO_color_palette: - case FO_color_name_palette: + case FO_name_table: case FO_15_material: case FO_texture: case FO_eyepoint_palette: @@ -344,9 +428,12 @@ is_ancillary(FltOpcode opcode) { return true; case FO_header: + case FO_mesh: + case FO_mesh_primitive: case FO_group: case FO_object: case FO_face: + case FO_light_point: case FO_dof: case FO_vertex_list: case FO_morph_list: @@ -356,10 +443,14 @@ is_ancillary(FltOpcode opcode) { case FO_sound: case FO_light_source: case FO_road_segment: + case FO_road_construction: case FO_road_path: case FO_clip_region: case FO_text: case FO_switch: + case FO_cat: + case FO_extension: + case FO_curve: return false; case FO_push: @@ -368,6 +459,8 @@ is_ancillary(FltOpcode opcode) { case FO_pop_face: case FO_push_attribute: case FO_pop_attribute: + case FO_push_extension: + case FO_pop_extension: case FO_instance: case FO_instance_ref: return false; @@ -397,6 +490,18 @@ create_new_record(FltOpcode opcode) const { case FO_face: return new FltFace(_header); + case FO_curve: + return new FltCurve(_header); + + case FO_mesh: + return new FltMesh(_header); + + case FO_local_vertex_pool: + return new FltLocalVertexPool(_header); + + case FO_mesh_primitive: + return new FltMeshPrimitive(_header); + case FO_vertex_list: return new FltVertexList(_header); @@ -497,6 +602,26 @@ read_record_and_children(FltRecordReader &reader) { } } + } else if (reader.get_opcode() == FO_push_extension) { + // A push extension begins a new list of extensions. + result = reader.advance(); + if (result != FE_ok) { + return result; + } + + while (reader.get_opcode() != FO_pop_extension) { + PT(FltRecord) extension = create_new_record(reader.get_opcode()); + FltError result = extension->read_record_and_children(reader); + if (result != FE_ok) { + return result; + } + add_extension(extension); + if (reader.eof() || reader.error()) { + assert(!flt_error_abort); + return FE_end_of_file; + } + } + } else if (is_ancillary(reader.get_opcode())) { // An unsupported ancillary record. Skip it. PT(FltRecord) ancillary = create_new_record(reader.get_opcode()); @@ -602,6 +727,23 @@ write_record_and_children(FltRecordWriter &writer) const { } } + // Any extensions? + if (!_extensions.empty()) { + result = writer.write_record(FO_push_face); + if (result != FE_ok) { + return result; + } + + for (ci = _extensions.begin(); ci != _extensions.end(); ++ci) { + (*ci)->write_record_and_children(writer); + } + + result = writer.write_record(FO_pop_face); + if (result != FE_ok) { + return result; + } + } + // Finally, write all the children. if (!_children.empty()) { result = writer.write_record(FO_push); diff --git a/pandatool/src/flt/fltRecord.h b/pandatool/src/flt/fltRecord.h index 0f31faf2b5..a861447986 100644 --- a/pandatool/src/flt/fltRecord.h +++ b/pandatool/src/flt/fltRecord.h @@ -18,6 +18,7 @@ class FltHeader; class FltRecordReader; class FltRecordWriter; +class DatagramIterator; //////////////////////////////////////////////////////////////////// // Class : FltRecord @@ -42,6 +43,11 @@ public: void clear_subfaces(); void add_subface(FltRecord *subface); + int get_num_extensions() const; + FltRecord *get_extension(int n) const; + void clear_extensions(); + void add_extension(FltRecord *extension); + int get_num_ancillary() const; FltRecord *get_ancillary(int n) const; void clear_ancillary(); @@ -52,6 +58,8 @@ public: void clear_comment(); void set_comment(const string &comment); + void check_remaining_size(const DatagramIterator &iterator) const; + virtual void output(ostream &out) const; virtual void write(ostream &out, int indent_level = 0) const; @@ -76,6 +84,7 @@ private: typedef vector Records; Records _children; Records _subfaces; + Records _extensions; Records _ancillary; string _comment; diff --git a/pandatool/src/flt/fltRecordReader.cxx b/pandatool/src/flt/fltRecordReader.cxx index bf1935f8ee..83d75a6ac1 100644 --- a/pandatool/src/flt/fltRecordReader.cxx +++ b/pandatool/src/flt/fltRecordReader.cxx @@ -10,6 +10,8 @@ #include +static const int header_size = 4; + //////////////////////////////////////////////////////////////////// // Function: FltRecordReader::Constructor // Access: Public @@ -23,6 +25,12 @@ FltRecordReader(istream &in) : _record_length = 0; _iterator = (DatagramIterator *)NULL; _state = S_begin; + _next_error = FE_ok; + _next_opcode = FO_none; + _next_record_length = 0; + + // Read the first header to get us going. + read_next_header(); } //////////////////////////////////////////////////////////////////// @@ -110,13 +118,7 @@ advance(bool ok_eof) { _iterator = (DatagramIterator *)NULL; } - // Get the first four bytes of the record. This will be the opcode - // and length. - static const int header_size = 4; - char bytes[header_size]; - _in.read(bytes, header_size); - - if (_in.eof()) { + if (_next_error == FE_end_of_file) { _state = S_eof; if (ok_eof) { return FE_ok; @@ -124,30 +126,23 @@ advance(bool ok_eof) { assert(!flt_error_abort); return FE_end_of_file; - } else if (_in.fail()) { + } else if (_next_error != FE_ok) { _state = S_error; assert(!flt_error_abort); - return FE_read_error; + return _next_error; } - // Now extract out the opcode and length. - Datagram dg(bytes, header_size); - DatagramIterator dgi(dg); - _opcode = (FltOpcode)dgi.get_be_int16(); - _record_length = dgi.get_be_uint16(); - - if (_record_length < header_size) { - assert(!flt_error_abort); - return FE_invalid_record; - } + _opcode = _next_opcode; + _record_length = _next_record_length; if (flt_cat.is_debug()) { flt_cat.debug() - << "Reading " << _opcode << " of length " << _record_length << "\n"; + << "Reading " << _opcode + << " of length " << _record_length << "\n"; } // And now read the full record based on the length. - int length = _record_length - header_size; + int length = _next_record_length - header_size; char *buffer = new char[length]; if (length > 0) { _in.read(buffer, length); @@ -167,6 +162,40 @@ advance(bool ok_eof) { return FE_read_error; } + // Check out the next header in case it's a continuation. + read_next_header(); + while (_next_error == FE_ok && _next_opcode == FO_continuation) { + if (flt_cat.is_debug()) { + flt_cat.debug() + << "Reading continuation of length " << _next_record_length << "\n"; + } + + // Read the continuation and tack it on. + _record_length += _next_record_length; + length = _next_record_length - header_size; + + buffer = new char[length]; + if (length > 0) { + _in.read(buffer, length); + } + _datagram.append_data(buffer, length); + delete[] buffer; + + if (_in.eof()) { + _state = S_eof; + assert(!flt_error_abort); + return FE_end_of_file; + } + + if (_in.fail()) { + _state = S_error; + assert(!flt_error_abort); + return FE_read_error; + } + + read_next_header(); + } + // Finally, create a new iterator to read this record. _iterator = new DatagramIterator(_datagram); _state = S_normal; @@ -196,3 +225,39 @@ error() const { return _state == S_error; } +//////////////////////////////////////////////////////////////////// +// Function: FltRecordReader::read_next_header +// Access: Private +// Description: Reads the four-byte header for the next record, which +// contains the next opcode and record length. +// +// We need read the next header in advance so we can +// check to see if it happens to be a continuation +// record. If it is, we will need to concatenate the +// records together before returning. +//////////////////////////////////////////////////////////////////// +void FltRecordReader:: +read_next_header() { + char bytes[header_size]; + _in.read(bytes, header_size); + + if (_in.eof()) { + _next_error = FE_end_of_file; + return; + + } else if (_in.fail()) { + _next_error = FE_read_error; + return; + } + + // Now extract out the opcode and length. + Datagram dg(bytes, header_size); + DatagramIterator dgi(dg); + _next_opcode = (FltOpcode)dgi.get_be_int16(); + _next_record_length = dgi.get_be_uint16(); + + if (_next_record_length < header_size) { + _next_error = FE_invalid_record; + return; + } +} diff --git a/pandatool/src/flt/fltRecordReader.h b/pandatool/src/flt/fltRecordReader.h index a60a54a563..4bf8174e7a 100644 --- a/pandatool/src/flt/fltRecordReader.h +++ b/pandatool/src/flt/fltRecordReader.h @@ -38,11 +38,17 @@ public: bool error() const; private: + void read_next_header(); + istream &_in; Datagram _datagram; FltOpcode _opcode; int _record_length; DatagramIterator *_iterator; + + FltError _next_error; + FltOpcode _next_opcode; + int _next_record_length; enum State { S_begin, diff --git a/pandatool/src/flt/fltRecordWriter.cxx b/pandatool/src/flt/fltRecordWriter.cxx index 27446b17f4..2161960d5b 100644 --- a/pandatool/src/flt/fltRecordWriter.cxx +++ b/pandatool/src/flt/fltRecordWriter.cxx @@ -12,6 +12,13 @@ #include +static const int header_size = 4; + +// Don't attempt to write more than this number of bytes in one +// record. If the record requires more than this, use continuation +// records. +static const int max_write_length = 65532; + //////////////////////////////////////////////////////////////////// // Function: FltRecordWriter::Constructor // Access: Public @@ -76,33 +83,43 @@ update_datagram() { //////////////////////////////////////////////////////////////////// FltError FltRecordWriter:: advance() { - if (flt_cat.is_debug()) { - flt_cat.debug() - << "Writing " << _opcode << " of length " - << _datagram.get_length() << "\n"; - } + int start_byte = 0; + int write_length = + min((int)_datagram.get_length() - start_byte, max_write_length - header_size); + FltOpcode opcode = _opcode; - // Build a mini-datagram to write the header. - static const int header_size = 4; + do { + if (flt_cat.is_debug()) { + flt_cat.debug() + << "Writing " << opcode << " of length " + << write_length + header_size << "\n"; + } - Datagram dg; - dg.add_be_int16(_opcode); - dg.add_be_int16(_datagram.get_length() + header_size); + // Build a mini-datagram to write the header. + Datagram dg; + dg.add_be_int16(opcode); + dg.add_be_int16(write_length + header_size); - nassertr((int)dg.get_length() == header_size, FE_internal); + nassertr((int)dg.get_length() == header_size, FE_internal); - _out.write(dg.get_message().data(), dg.get_length()); - if (_out.fail()) { - assert(!flt_error_abort); - return FE_write_error; - } + _out.write((const char *)dg.get_data(), dg.get_length()); + if (_out.fail()) { + assert(!flt_error_abort); + return FE_write_error; + } - // Now write the rest of the record. - _out.write(_datagram.get_message().data(), _datagram.get_length()); - if (_out.fail()) { - assert(!flt_error_abort); - return FE_write_error; - } + // Now write the rest of the record. + _out.write((const char *)_datagram.get_data() + start_byte, write_length); + if (_out.fail()) { + assert(!flt_error_abort); + return FE_write_error; + } + + start_byte += write_length; + write_length = + min((int)_datagram.get_length() - start_byte, max_write_length - header_size); + opcode = FO_continuation; + } while (write_length > 0); _datagram.clear(); _opcode = FO_none; diff --git a/pandatool/src/flt/fltTexture.cxx b/pandatool/src/flt/fltTexture.cxx index 7395bfb344..72661e49d6 100644 --- a/pandatool/src/flt/fltTexture.cxx +++ b/pandatool/src/flt/fltTexture.cxx @@ -214,7 +214,7 @@ extract_record(FltRecordReader &reader) { nout << "Unable to read attribute file " << get_attr_filename() << "\n"; } - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } @@ -343,7 +343,19 @@ unpack_attr(const Datagram &datagram) { } } - nassertr(iterator.get_remaining_size() == 0, FE_ok); + if (iterator.get_remaining_size() != 0) { + int num_defs = iterator.get_be_int32(); + while (num_defs > 0) { + SubtextureDef def; + def._name = iterator.get_fixed_string(32); + def._left = iterator.get_be_int32(); + def._bottom = iterator.get_be_int32(); + def._right = iterator.get_be_int32(); + def._top = iterator.get_be_int32(); + } + } + + check_remaining_size(iterator); return FE_ok; } @@ -430,12 +442,28 @@ pack_attr(Datagram &datagram) const { for (pi = _geospecific_control_points.begin(); pi != _geospecific_control_points.end(); ++pi) { - datagram.add_be_float64((*pi)._uv[0]); - datagram.add_be_float64((*pi)._uv[1]); - datagram.add_be_float64((*pi)._real_earth[0]); - datagram.add_be_float64((*pi)._real_earth[1]); + const GeospecificControlPoint &gcp = (*pi); + datagram.add_be_float64(gcp._uv[0]); + datagram.add_be_float64(gcp._uv[1]); + datagram.add_be_float64(gcp._real_earth[0]); + datagram.add_be_float64(gcp._real_earth[1]); } } + // Also write out the subtexture definitions. + datagram.add_be_int32(_subtexture_defs.size()); + SubtextureDefs::const_iterator di; + for (di = _subtexture_defs.begin(); + di != _subtexture_defs.end(); + ++di) { + const SubtextureDef &def = (*di); + datagram.add_fixed_string(def._name, 31); + datagram.add_int8(0); + datagram.add_be_int32(def._left); + datagram.add_be_int32(def._bottom); + datagram.add_be_int32(def._right); + datagram.add_be_int32(def._top); + } + return FE_ok; } diff --git a/pandatool/src/flt/fltTexture.h b/pandatool/src/flt/fltTexture.h index 0a725c3503..ba3ded122b 100644 --- a/pandatool/src/flt/fltTexture.h +++ b/pandatool/src/flt/fltTexture.h @@ -145,6 +145,15 @@ public: typedef vector GeospecificControlPoints; + struct SubtextureDef { + string _name; + int _left; + int _bottom; + int _right; + int _top; + }; + typedef vector SubtextureDefs; + int _num_texels_u; int _num_texels_v; int _real_world_size_u; @@ -199,6 +208,7 @@ public: string _comment; int _file_version; GeospecificControlPoints _geospecific_control_points; + SubtextureDefs _subtexture_defs; protected: virtual bool extract_record(FltRecordReader &reader); diff --git a/pandatool/src/flt/fltTransformGeneralMatrix.cxx b/pandatool/src/flt/fltTransformGeneralMatrix.cxx index 7fb7cd8ab4..aa2687043c 100644 --- a/pandatool/src/flt/fltTransformGeneralMatrix.cxx +++ b/pandatool/src/flt/fltTransformGeneralMatrix.cxx @@ -61,7 +61,7 @@ extract_record(FltRecordReader &reader) { } } - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltTransformPut.cxx b/pandatool/src/flt/fltTransformPut.cxx index 5a50e9a71a..c9087abe46 100644 --- a/pandatool/src/flt/fltTransformPut.cxx +++ b/pandatool/src/flt/fltTransformPut.cxx @@ -166,7 +166,7 @@ extract_record(FltRecordReader &reader) { recompute_matrix(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltTransformRotateAboutEdge.cxx b/pandatool/src/flt/fltTransformRotateAboutEdge.cxx index 545a5b0c6b..e85e6d1690 100644 --- a/pandatool/src/flt/fltTransformRotateAboutEdge.cxx +++ b/pandatool/src/flt/fltTransformRotateAboutEdge.cxx @@ -117,7 +117,7 @@ extract_record(FltRecordReader &reader) { recompute_matrix(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltTransformRotateAboutPoint.cxx b/pandatool/src/flt/fltTransformRotateAboutPoint.cxx index 71a27b3062..a9a06a77e3 100644 --- a/pandatool/src/flt/fltTransformRotateAboutPoint.cxx +++ b/pandatool/src/flt/fltTransformRotateAboutPoint.cxx @@ -116,7 +116,7 @@ extract_record(FltRecordReader &reader) { recompute_matrix(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltTransformRotateScale.cxx b/pandatool/src/flt/fltTransformRotateScale.cxx index 09d0947bb0..9a134de663 100644 --- a/pandatool/src/flt/fltTransformRotateScale.cxx +++ b/pandatool/src/flt/fltTransformRotateScale.cxx @@ -187,7 +187,7 @@ extract_record(FltRecordReader &reader) { recompute_matrix(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltTransformScale.cxx b/pandatool/src/flt/fltTransformScale.cxx index fc5b6fce8e..8d8cd2c35d 100644 --- a/pandatool/src/flt/fltTransformScale.cxx +++ b/pandatool/src/flt/fltTransformScale.cxx @@ -96,7 +96,7 @@ extract_record(FltRecordReader &reader) { recompute_matrix(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltTransformTranslate.cxx b/pandatool/src/flt/fltTransformTranslate.cxx index 59ce8c6958..877bcd520e 100644 --- a/pandatool/src/flt/fltTransformTranslate.cxx +++ b/pandatool/src/flt/fltTransformTranslate.cxx @@ -95,7 +95,7 @@ extract_record(FltRecordReader &reader) { recompute_matrix(); - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltVertex.cxx b/pandatool/src/flt/fltVertex.cxx index eecf073745..cf3f2bf7bb 100644 --- a/pandatool/src/flt/fltVertex.cxx +++ b/pandatool/src/flt/fltVertex.cxx @@ -179,7 +179,7 @@ extract_record(FltRecordReader &reader) { iterator.skip_bytes(4); } - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/fltVertexList.cxx b/pandatool/src/flt/fltVertexList.cxx index 2589c7aa60..6af0a0effa 100644 --- a/pandatool/src/flt/fltVertexList.cxx +++ b/pandatool/src/flt/fltVertexList.cxx @@ -98,7 +98,7 @@ extract_record(FltRecordReader &reader) { _vertices.push_back(_header->get_vertex_by_offset(vertex_offset)); } - nassertr(iterator.get_remaining_size() == 0, true); + check_remaining_size(iterator); return true; } diff --git a/pandatool/src/flt/test_flt.cxx b/pandatool/src/flt/test_flt.cxx index 9f15bbb4b7..59e0c94a2f 100644 --- a/pandatool/src/flt/test_flt.cxx +++ b/pandatool/src/flt/test_flt.cxx @@ -48,8 +48,8 @@ main(int argc, char *argv[]) { header->set_texture_path(texture_path); FltError result = header->read_flt(filename); - cerr << "Read result is " << result << "\n\n"; - cerr << "Version is " << header->get_flt_version() << "\n"; + cerr << "Read result is " << result << "\n" + << "Version is " << header->get_flt_version() << "\n"; header->check_version(); if (result == FE_ok) {