--- /dev/null
+map objects module
+==================
+
+Objective:
+----------
+
+#1 Turn the md3 code into a module. That is handle all aspects of map objects in
+a module. This involves:
+- the rendering of the model (sleep mode / shader reload are associated issues)
+- the manipulation in the editor (moving, rotating, (scaling?))
+
+#2 Have an API generic enough to support other formats than md3. (md1 / md2 for
+multiple games support, any other formats).
+
+What we have:
+-------------
+
+What is the current implementation of md3 support? Were are the important
+features that we will need to work with?
+
+"misc_model" is the required classname for any map object
+
+entity_t::md3Class
+eclass_t *md3Class;
+This holds the actual md3 object and the rendering information (tri soup,
+shader etc.)
+entity_t also has vRotation and vScale which are particular to the model
+
+for selection of the brush (selection is preliminary step before any
+manipulation operation), we create a bounding box from the md3 information
+and use the entity's brush list as storage for it.
+
+Requirements:
+-------------
+
+Some technical requirements go on top of our objective given the existing
+implementation. The most important one is that the changes applied to the
+core must remain focused around the md3 functionality, and must also lay
+out the basics of some wider changes. We can identify some of those changes:
+
+- introducing a more generalized way of selecting and manipulation things
+in the editor.
+
+- introducing a more generic way of rendering objects in the editor.
+
+More specifically, the details of rendering and manipulation:
+
+transformation
+ translate&rotate:
+ A transformation increment is provided
+ The object is transformed by a specified increment.
+ Depending on the object type, the transformations may affect
+ the local coordinate space transformation instead of the object.
+ This local transformation is used in selection and rendering.
+
+selection:
+ ray:
+ Radiant asks model for its world-relative axis-alignedbounding box.
+ Radiant does intersection test with this bounding box.
+ If test shows intersection, radiant gives model a ray_t, model tests
+ for intersection with ray, model returns bool true if intersection
+ A selection ray in world-space (origin+direction) is provided.
+ The object must say whether or not it intersects with the ray.
+ map objects have a special configuration to test on bounding box or trisoup
+ this is set in preferences independently from the true/false selection tests
+ area:
+ radiant uses a bounding box for area selection. (bounding box can be
+ infinite in some directions for the 'select tall' operations, in practice
+ we just make them big enough).
+
+rendering:
+ geometry:
+ Radiant tells the object what combination of 4 opengl states is currently active:
+ none - draw as wireframe
+ fill - draw as filled
+ alpha blend - provide an opacity value
+ texture_2d - provide a texture and texture coordinates
+ lighting - provide normals, enable/disable smooth shading
+ The object uses opengl to set up its geometry and to draw itself.
+ material:
+ The object provides a material name and is assigned a reference to
+ a shader that matches the name.
+ The shader contains the texture ID and the opacity value.
+ The shader is a reference to an external script and must be refreshed
+ on request.
+
+
+Proposed implementation:
+========================
+
+changes in shared interfaces (include/ directory):
+--------------------------------------------------
+
+The following new interfaces will be added:
+most likely those interfaces will be implemented in the module
+
+/*!
+something that can be selected
+*/
+class ISelect
+{
+ bool TestRay(ray_t) = 0
+ bool TestBox(vec3_t vec_min, vec3_t vec_max) = 0;
+}
+
+/*!
+something that can be selected for edition
+this must be synced with entity epairs
+(such as origin and angles keys)
+*/
+class IEdit
+{
+ void Translate(vec3_t v) = 0;
+ void Rotate(vec3_t origin, vec3_t angles) = 0;
+}
+
+for rendering, the existing IGL2DWindow and IGL3DWindow APIs
+we can define
+class IRender : public IGL2DWindow, public IGL3DWindow
+so that we have the Render2D and Render3D on the same class
+
+entity_t will have to be modified, adding the following struct:
+typedef struct entity_interfaces_s
+{
+ ISelect *pSelect
+ IEdit *pEdit
+ IRender *pRender
+}
+entity_interfaces_t;
+
+When one of the pointers inside entity_t::entity_interfaces
+is != we will handle the entity differently that what we are
+doing by default. We will rely on these APIs for rendering,
+manipulation etc.
+
+the AABB issue:
+
+
+changes in the core:
+--------------------
+
+In all cases where the entity_t has to be drawn, tested for selection,
+manipulated (translation and rotation), add new code to go through the APIs.
+
+
+md3 module:
+-----------
+
+static function table API
+
+- registering of "model" module
+need some minors? "md3" etc.
+
+- BuildEntity(entity_t)
+if an entity involved with models is found, core will call this
+entity_t::entity_interfaces will be filled with the relevant classes
+
+(NOTE:L we don't have a need right now to manipulate a model that
+would not be part of an entity. so let's not try to guess what it
+would be like)
+
+CModel
+stores the trisoup, local AABBs, references to shaders
+(CModel potentially needs a CModelManager to handle
+model loads and cached models queries)
+
+CModelEntity implements IRender ISelect IEdit
+stores an entity_t*
+implements the interfaces pointed to in the entity_t
+is reference counted obviously
+stores a CModel*, calls up to it with entity information for rendering
+
projects / voretournament / voretournament.git / blobdiff