RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
open_toontown_panda3d/panda/src/grutil/meshDrawer.cxx

536 lines
16 KiB
C++
Raw Blame History

/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file meshDrawer.cxx
* @author treeform
* @date 2008-12-19
*/
#include "meshDrawer.h"
#include "geomVertexFormat.h"
#include "geomVertexArrayFormat.h"
#include "geomVertexData.h"
#include "geomVertexWriter.h"
#include "geomVertexRewriter.h"
#include "camera.h"
#include "boundingSphere.h"
#include "geomTristrips.h"
#include "geomTriangles.h"
#include "geom.h"
#include "geomNode.h"
#include "pnmPainter.h"
#include "pnmBrush.h"
#include "lvecBase4.h"
#include "lvector3.h"
#include "pandaNode.h"
TypeHandle MeshDrawer::_type_handle;
PN_stdfloat randFloat() {
return ((PN_stdfloat)rand() / (PN_stdfloat)RAND_MAX);
}
/**
* Creates a system with a given budget.
*/
void MeshDrawer::generator(int budget) {
// create enough triangles for budget:
_vdata = new GeomVertexData(_root.get_name(), GeomVertexFormat::get_v3n3c4t2(), Geom::UH_static);//UH_dynamic);
_vdata->unclean_set_num_rows(budget * 3);
{
GeomVertexWriter tvertex(_vdata, "vertex");
GeomVertexWriter tnormal(_vdata, "normal");
GeomVertexWriter tuv(_vdata, "texcoord");
GeomVertexWriter tcolor(_vdata, "color");
// iterate and fill _up a geom with random data so that it will not be
// optimized out by panda3d system
for (int i = 0; i < budget; i++) {
for (int vert = 0; vert < 3; vert++) {
LVector3 vec3 = LVector3(randFloat()+1000,randFloat(),randFloat())*.001;
LVector4 vec4 = LVector4(1,1,1,randFloat());
LVector2 vec2 = LVector2(0,randFloat());
tvertex.set_data3(vec3);
tcolor.set_data4(vec4);
tuv.set_data2(vec2);
tnormal.set_data3(vec3);
}
}
}
// create our node and attach it to this node path
_prim = new GeomTriangles(Geom::UH_static);
_prim->add_next_vertices(budget * 3);
_prim->close_primitive();
_geom = new Geom(_vdata);
_geom->add_primitive(_prim);
if (_geomnode == nullptr) {
_geomnode = new GeomNode("__MeshDrawer_GeomNode");
_root.attach_new_node(_geomnode);
} else {
_geomnode->remove_all_geoms();
}
_geomnode->add_geom(_geom);
_last_clear_index = budget;
}
/**
* Pass the current camera node and the root node. Passing the camera is
* required to generate bill boards that face it.
*/
void MeshDrawer::begin(NodePath camera, NodePath render) {
// sanity check
assert(render.get_error_type() == NodePath::ET_ok);
assert(camera.get_error_type() == NodePath::ET_ok);
// remember our arguments
_camera = camera;
_render = render;
// compute some help vectors
_eyePos = camera.get_pos();
_up = _render.get_relative_vector(camera, LVector3(0, 0, 1));
_right = _render.get_relative_vector(camera, LVector3(1, 0, 0));
_b1 = - _right - _up;
_b2 = _right - _up;
_b3 = _right + _up;
_b4 = - _right + _up;
// recreate our rewriters
if (_vertex != nullptr) delete _vertex;
if (_normal != nullptr) delete _normal;
if (_uv != nullptr) delete _uv;
if (_color != nullptr) delete _color;
if (_vdata == nullptr) {
generator(_budget);
}
_vertex = new GeomVertexRewriter(_vdata, "vertex");
_uv = new GeomVertexRewriter(_vdata, "texcoord");
_normal = new GeomVertexRewriter(_vdata, "normal");
_color = new GeomVertexRewriter(_vdata, "color");
_dprim = _prim->decompose();
// reseta our clearning indexes
_start_clear_index = 0;
_end_clear_index = _budget;
_clear_index = _start_clear_index;
}
/**
* Finish the drawing and clearing off the remaining vertexes.
*/
void MeshDrawer::end() {
// clear the unused triangles at the end of the buffer
for(int i = _clear_index ; i < _last_clear_index; i ++ ) {
_vertex->add_data3(0,0,0);
_vertex->add_data3(0,0,0);
_vertex->add_data3(0,0,0);
}
// don't clear more then you have too
_last_clear_index = _clear_index;
// delete the re writers
delete _vertex; _vertex = nullptr;
delete _uv; _uv = nullptr;
delete _normal; _normal = nullptr;
delete _color; _color = nullptr;
}
/**
* Draws a particle that is sort of like a bill board but has an extra
* rotation component. Frame contains u,v,u-size,v-size quadruple.
*/
void MeshDrawer::particle(const LVector3 &pos, const LVector4 &frame, PN_stdfloat size,
const LVector4 &color, PN_stdfloat rotation) {
rotation = rotation / 57.29578;
LVector3 v1 = pos + _b1*size*sin(rotation) + _b2*size*cos(rotation);
LVector3 v2 = pos + _b2*size*sin(rotation) + _b3*size*cos(rotation);
LVector3 v3 = pos + _b3*size*sin(rotation) + _b4*size*cos(rotation);
LVector3 v4 = pos + _b4*size*sin(rotation) + _b1*size*cos(rotation);
PN_stdfloat u = frame.get_x();
PN_stdfloat v = frame.get_y();
PN_stdfloat us = frame.get_z();
PN_stdfloat vs = frame.get_w();
tri(
v1, color, LVector2(u,v),
v2, color, LVector2(u+us,v),
v3, color, LVector2(u+us,v+vs));
tri(
v3, color, LVector2(u+us,v+vs),
v4, color, LVector2(u,v+vs),
v1, color, LVector2(u,v));
}
/**
* Works just like particle but accepts 2 frames and a blend (from 0 to 1)
* component between them Frame contains u,v,u-size,v-size quadruple.
*/
void MeshDrawer::blended_particle(const LVector3 &pos, const LVector4 &frame1,
const LVector4 &frame2, PN_stdfloat blend, PN_stdfloat size, const LVector4 &color, PN_stdfloat rotation) {
LVector4 c2 = color;
PN_stdfloat original_w = c2.get_w();
c2.set_w((1.f-blend)*original_w);
particle(pos,frame1,size,c2,rotation);
c2.set_w(blend*original_w);
particle(pos,frame2,size,c2,rotation);
}
/**
* Draws a billboard - particle with no rotation. Billboards always face the
* camera. Frame contains u,v,u-size,v-size quadruple.
*/
void MeshDrawer::billboard(const LVector3 &pos, const LVector4 &frame, PN_stdfloat size,
const LVector4 &_color) {
LVector3 v1 = pos + _b1*size;
LVector3 v2 = pos + _b2*size;
LVector3 v3 = pos + _b3*size;
LVector3 v4 = pos + _b4*size;
PN_stdfloat u = frame.get_x();
PN_stdfloat v = frame.get_y();
PN_stdfloat us = frame.get_z();
PN_stdfloat vs = frame.get_w();
tri(
v1, _color, LVector2(u,v),
v2, _color, LVector2(u+us,v),
v3, _color, LVector2(u+us,v+vs));
tri(
v3, _color, LVector2(u+us,v+vs),
v4, _color, LVector2(u,v+vs),
v1, _color, LVector2(u,v));
}
/**
* Draws a segment a line with a thickness. That has billboarding effect.
* Frame contains u,v,u-size,v-size quadruple.
*/
void MeshDrawer::segment(const LVector3 &start, const LVector3 &stop, const LVector4 &frame,
PN_stdfloat thickness, const LVector4 &color) {
link_segment(start, frame, thickness, color);
link_segment(stop, frame, thickness, color);
link_segment_end(frame, color);
}
/**
* Draws a segment a line with a thickness. This segment does not use the
* bill boarding behavior and instead draws 2 planes in a cross. Stars at
* start and ends at stop. Frame contains u,v,u-size,v-size quadruple.
*/
void MeshDrawer::cross_segment(const LVector3 &start, const LVector3 &stop, const LVector4 &frame,
PN_stdfloat thickness, const LVector4 &color) {
PN_stdfloat u = frame.get_x();
PN_stdfloat v = frame.get_y();
PN_stdfloat us = frame.get_z();
PN_stdfloat vs = frame.get_w();
LVector3 v1 = start - _up*thickness;
LVector3 v2 = stop - _up*thickness;
LVector3 v3 = stop + _up*thickness;
LVector3 v4 = start + _up*thickness;
tri(v1, color, LVector2(u,v),
v2, color, LVector2(u+us,v),
v3, color, LVector2(u+us,v+vs));
tri(v3, color, LVector2(u+us,v+vs),
v4, color, LVector2(u,v+vs),
v1, color, LVector2(u,v));
v1 = start - _right*thickness;
v2 = stop - _right*thickness;
v3 = stop + _right*thickness;
v4 = start + _right*thickness;
tri(v1, color, LVector2(u,v),
v2, color, LVector2(u+us,v),
v3, color, LVector2(u+us,v+vs));
tri(v3, color, LVector2(u+us,v+vs),
v4, color, LVector2(u,v+vs),
v1, color, LVector2(u,v));
}
/**
* Draws a segment a line with different thickness and color on both sides.
* Stars at start and ends at stop. Frame contains u,v,u-size,v-size
* quadruple.
*/
void MeshDrawer::uneven_segment(const LVector3 &start, const LVector3 &stop,
const LVector4 &frame, PN_stdfloat thickness_start, const LVector4 &color_start,
PN_stdfloat thickness_stop, const LVector4 &color_stop) {
PN_stdfloat u = frame.get_x();
PN_stdfloat v = frame.get_y();
PN_stdfloat us = frame.get_z();
PN_stdfloat vs = frame.get_w();
LVector3 v1 = start - _up*thickness_start;
LVector3 v2 = stop - _up*thickness_stop;
LVector3 v3 = stop + _up*thickness_stop;
LVector3 v4 = start + _up*thickness_start;
tri(v1, color_start, LVector2(u,v),
v2, color_stop, LVector2(u+us,v),
v3, color_stop, LVector2(u+us,v+vs));
tri(v3, color_stop, LVector2(u+us,v+vs),
v4, color_start, LVector2(u,v+vs),
v1, color_start, LVector2(u,v));
v1 = start - _right*thickness_start;
v2 = stop - _right*thickness_stop;
v3 = stop + _right*thickness_stop;
v4 = start + _right*thickness_start;
tri(v1, color_start, LVector2(u,v),
v2, color_stop, LVector2(u+us,v),
v3, color_stop, LVector2(u+us,v+vs));
tri(v3, color_stop, LVector2(u+us,v+vs),
v4, color_start, LVector2(u,v+vs),
v1, color_start, LVector2(u,v));
}
/**
* Draws number of particles in a sphere like emitter. Frame contains
* u,v,u-size,v-size quadruple.
*/
void MeshDrawer::explosion(
const LVector3 &pos, const LVector4 &frame, PN_stdfloat size, const LVector4 &_color,
int seed, int number, PN_stdfloat distance) {
srand(seed);
LVector3 relative_pos;
for(int i = 0; i < number; i++) {
relative_pos = LVector3(randFloat()-.5f,randFloat()-.5f,randFloat()-.5f);
relative_pos.normalize();
relative_pos *= randFloat()*distance;
particle(relative_pos+pos,frame,size,_color,randFloat()*360.0f);
}
}
/**
* Draws a number of particles in a big line with a shift dictated by the
* offset. Frame contains u,v,u-size,v-size quadruple.
*/
void MeshDrawer::stream(const LVector3 &start, const LVector3 &stop, const LVector4 &frame, PN_stdfloat size, const LVector4 &_color,
int number, PN_stdfloat offset) {
offset = offset-floor(offset);
LVector3 relative_pos = stop;
LVector3 vec = stop - start;
PN_stdfloat distance = vec.length();
vec.normalize();
for(int i = 0; i < number; i++) {
relative_pos = start + vec * ((i+offset)*(distance/PN_stdfloat(number)));
billboard(relative_pos,frame,size,_color);
}
}
/**
* Draws the geometry that is inside this node path into the MeshDrawer
* object. This performs a similar functions as RigidBodyCombiner but for
* very dynamic situations that share the same texture like physcal chunks of
* explosions. It can be a little slow
*/
void MeshDrawer::geometry(NodePath draw_node) {
assert(_render.get_error_type() == NodePath::ET_ok);
LVector4 color = LVector4(1,1,1,1);
LVector3 vec[3];
LVector2 uv[3];
// process node
NodePathCollection geom_collection = draw_node.find_all_matches("**/+GeomNode");
for(int i=0; i < geom_collection.get_num_paths(); i++ ) {
NodePath current_node_path = geom_collection.get_path(i);
PT(GeomNode) geomNode = DCAST(GeomNode, current_node_path.node());
// process geom node
for(int j=0; j<geomNode->get_num_geoms(); j++) {
CPT(Geom) geom = geomNode->get_geom(j);
CPT(GeomVertexData) v_data = geom->get_vertex_data();
GeomVertexReader *prim_vertex_reader = new GeomVertexReader(v_data, "vertex");
GeomVertexReader *prim_uv_reader = new GeomVertexReader(v_data, "texcoord");
for (size_t k = 0; k < geom->get_num_primitives(); ++k) {
CPT(GeomPrimitive) prim1 = geom->get_primitive(k);
CPT(GeomPrimitive) _prim = prim1->decompose();
// process primitive
for(int p=0; p < _prim->get_num_primitives();p++) {
int s = _prim->get_primitive_start(p);
int e = _prim->get_primitive_end(p);
int indx_over = 0;
// process polygon
for(int idx=s; idx<e; idx++) {
int vidx = _prim->get_vertex(idx);
prim_vertex_reader->set_row_unsafe(vidx);
prim_uv_reader->set_row_unsafe(vidx);
vec[indx_over] = _render.get_relative_point(
current_node_path,prim_vertex_reader->get_data3());
uv[indx_over] = prim_uv_reader->get_data2();
indx_over++;
if (indx_over > 2) break;
}
// draw polygon
tri(vec[0],color,uv[0],
vec[1],color,uv[1],
vec[2],color,uv[2]);
}
// if we are over budget just quit
if( _clear_index > _end_clear_index) return;
}
// delete our reders
delete prim_vertex_reader;
delete prim_uv_reader;
}
}
}
/**
* Stars or continues linked segment. Control position, frame, thickness and
* color with parameters. Frame contains u,v,u-size,v-size quadruple.
*/
void MeshDrawer::
link_segment(const LVector3 &pos, const LVector4 &frame,
PN_stdfloat thickness, const LVector4 &color) {
assert(_render.get_error_type() == NodePath::ET_ok);
assert(_camera.get_error_type() == NodePath::ET_ok);
/*
* X
* ---X
* ===0---X
* ===0===0---X
* ===0===0===O---X
* ===0===0===0===End
*
* first call marks position X
* second call moves position and promises to draw segment
* it can't draw it yet because next segment might bend it
* third call finally draws segment
* and the chain continues till
* link_segment_end to flush the linking segments is called.
*/
// mark 1st position
if(_at_start==0) {
_last_pos = pos;
_last_thickness = thickness;
_last_color = color;
_at_start=1;
return;
}
LVector3 start = _last_pos;
LVector3 stop = pos;
LVector3 cam_start3d = _camera.get_relative_point(_render, start);
LPoint2 cam_start2d = LVector2();
LVector3 cam_stop3d = _camera.get_relative_point(_render, stop);
LPoint2 cam_stop2d = LVector2();
const Camera *camera;
DCAST_INTO_V(camera, _camera.node());
const Lens *lens = camera->get_lens();
lens->project(cam_start3d, cam_start2d);
lens->project(cam_stop3d, cam_stop2d);
LVector2 dif = cam_stop2d - cam_start2d;
PN_stdfloat rotation = atan2(dif.get_x(),dif.get_y());
LVector3 now_v1 = start + _b1*(PN_stdfloat)(thickness*sin(rotation)) + _b2*(PN_stdfloat)(thickness*cos(rotation));
LVector3 now_v4 = start + _b4*(PN_stdfloat)(thickness*sin(rotation)) + _b1*(PN_stdfloat)(thickness*cos(rotation));
LVector3 now_v2 = stop + _b2*(PN_stdfloat)(thickness*sin(rotation)) + _b3*(PN_stdfloat)(thickness*cos(rotation));
LVector3 now_v3 = stop + _b3*(PN_stdfloat)(thickness*sin(rotation)) + _b4*(PN_stdfloat)(thickness*cos(rotation));
// mark the segment we going to draw we need to draw it when we know what
// the next segment looks like because it can bend it a little
if(_at_start==1) {
_last_v1 = now_v1;
_last_v2 = now_v2;
_last_v3 = now_v3;
_last_v4 = now_v4;
_at_start = 2;
return;
}
// draw the last segment a little bent
LVector3 v1 = _last_v1;
LVector3 v2 = (_last_v2+now_v1)/2.0f;
LVector3 v3 = (_last_v3+now_v4)/2.0f;
LVector3 v4 = _last_v4;
// compute this frame
PN_stdfloat u = frame.get_x();
PN_stdfloat v = frame.get_y();
PN_stdfloat us = frame.get_z();
PN_stdfloat vs = frame.get_w();
tri(v1, _last_color, LVector2(u,v),
v2, color, LVector2(u+us,v),
v3, color, LVector2(u+us,v+vs));
tri(v3, color, LVector2(u+us,v+vs),
v4, _last_color, LVector2(u,v+vs),
v1, _last_color, LVector2(u,v));
// save this segment
_last_v1 = v2;
_last_v2 = now_v2;
_last_v3 = now_v3;
_last_v4 = v3;
// make this position
_last_pos = pos;
_last_thickness = thickness;
_last_color = color;
}
/**
* Finish drawing linked segments, needs at least two calls to link_segment
* before it can end the linked segment. Frame contains u,v,u-size,v-size
* quadruple.
*/
void MeshDrawer::link_segment_end(const LVector4 &frame, const LVector4 &color)
{
PN_stdfloat u = frame.get_x();
PN_stdfloat v = frame.get_y();
PN_stdfloat us = frame.get_z();
PN_stdfloat vs = frame.get_w();
tri(_last_v1, _last_color, LVector2(u,v),
_last_v2, color, LVector2(u+us,v),
_last_v3, color, LVector2(u+us,v+vs));
tri(_last_v3, color, LVector2(u+us,v+vs),
_last_v4, _last_color, LVector2(u,v+vs),
_last_v1, _last_color, LVector2(u,v));
_at_start = 0;
}
Reference in New Issue View Git Blame Copy Permalink