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/multitexReducer.cxx

1026 lines
35 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 multitexReducer.cxx
* @author drose
* @date 2004-11-30
*/
#include "multitexReducer.h"
#include "pandaNode.h"
#include "geomNode.h"
#include "geom.h"
#include "geomTransformer.h"
#include "accumulatedAttribs.h"
#include "sceneGraphReducer.h"
#include "renderState.h"
#include "transformState.h"
#include "graphicsOutput.h"
#include "displayRegion.h"
#include "camera.h"
#include "orthographicLens.h"
#include "cardMaker.h"
#include "colorAttrib.h"
#include "colorScaleAttrib.h"
#include "colorBlendAttrib.h"
#include "alphaTestAttrib.h"
#include "textureAttrib.h"
#include "config_grutil.h"
#include "config_gobj.h"
#include "dcast.h"
#include "geom.h"
#include "geomVertexWriter.h"
#include "geomVertexReader.h"
using std::max;
using std::min;
/**
*
*/
MultitexReducer::
MultitexReducer() {
_target_stage = TextureStage::get_default();
_use_geom = false;
_allow_tex_mat = false;
}
/**
*
*/
MultitexReducer::
~MultitexReducer() {
}
/**
* Removes the record of nodes that were previously discovered by scan().
*/
void MultitexReducer::
clear() {
_stages.clear();
_geom_node_list.clear();
}
/**
* Starts scanning the hierarchy beginning at the indicated node. Any
* GeomNodes discovered in the hierarchy with multitexture will be added to
* internal structures in the MultitexReducer so that a future call to
* flatten() will operate on all of these at once.
*
* The indicated transform and state are the state inherited from the node's
* ancestors; any multitexture operations will be accumulated from the
* indicated starting state.
*/
void MultitexReducer::
scan(PandaNode *node, const RenderState *state, const TransformState *transform) {
if (grutil_cat.is_debug()) {
grutil_cat.debug()
<< "scan(" << *node << ", " << *state << ", " << *transform << ")\n";
}
CPT(RenderState) next_state = state->compose(node->get_state());
CPT(TransformState) next_transform = transform->compose(node->get_transform());
// We must turn off any textures we come across in the scan() operation,
// since the flattened texture will be applied to the Geoms after the
// flatten() operation, and we don't want to still have a multitexture
// specified.
node->set_state(node->get_state()->remove_attrib(TextureAttrib::get_class_slot()));
if (node->is_geom_node()) {
scan_geom_node(DCAST(GeomNode, node), next_state, next_transform);
}
PandaNode::Children cr = node->get_children();
int num_children = cr.get_num_children();
for (int i = 0; i < num_children; i++) {
scan(cr.get_child(i), next_state, next_transform);
}
}
/**
* Specifies the target TextureStage (and InternalName) that will be left on
* each multitexture node after the flatten operation has completed.
*/
void MultitexReducer::
set_target(TextureStage *stage) {
_target_stage = stage;
}
/**
* Indicates whether the actual geometry will be used to generate the
* textures.
*
* If this is set to true, the geometry discovered by scan() will be used to
* generate the textures, which allows for the vertex and polygon colors to be
* made part of the texture itself (and makes the M_decal multitexture mode
* more reliable). However, this only works if the geometry does not contain
* multiple different polygons that map to the same UV range.
*
* If this is set to false (the default), a plain flat card will be used to
* generate the textures, which is more robust in general, but the resulting
* texture will not include vertex colors and M_decal won't work properly.
*
* Note that in case multiple sets of texture coordinates are in effect, then
* the additional sets will always use the geometry anyway regardless of the
* setting of this flag (but this will not affect vertex color).
*/
void MultitexReducer::
set_use_geom(bool use_geom) {
_use_geom = use_geom;
}
/**
* Indicates whether the resulting texture should be expected to be animated
* beyond its current range via a texture matrix (true), or whether the
* current range of texture coordinates will be sufficient forever (false).
*
* If this is set to true, then the entire texture image must be generated, in
* the assumption that the user may animate the texture around on the surface
* after it has been composed.
*
* If this is set to false (the default), then only the portion of the texture
* image which is actually in use must be generated, which may be a
* significant savings in texture memory.
*/
void MultitexReducer::
set_allow_tex_mat(bool allow_tex_mat) {
_allow_tex_mat = allow_tex_mat;
}
/**
* Actually performs the reducing operations on the nodes that were previously
* scanned.
*
* A window that can be used to create texture buffers suitable for rendering
* this geometry must be supplied. This specifies the particular GSG that
* will be used to composite the textures.
*/
void MultitexReducer::
flatten(GraphicsOutput *window) {
if (grutil_cat.is_debug()) {
grutil_cat.debug()
<< "Beginning flatten operation\n";
Stages::const_iterator mi;
for (mi = _stages.begin(); mi != _stages.end(); ++mi) {
const StageList &stage_list = (*mi).first;
const GeomList &geom_list = (*mi).second;
grutil_cat.debug(false)
<< "stage_list for:";
for (GeomList::const_iterator gi = geom_list.begin();
gi != geom_list.end();
++gi) {
const GeomInfo &geom_info = (*gi);
grutil_cat.debug(false)
<< " (" << geom_info._geom_node->get_name() << " g"
<< geom_info._index << ")";
}
grutil_cat.debug(false) << ":\n";
StageList::const_iterator si;
for (si = stage_list.begin(); si != stage_list.end(); ++si) {
const StageInfo &stage_info = (*si);
grutil_cat.debug(false)
<< " " << *stage_info._stage << " " << *stage_info._tex
<< " " << *stage_info._tex_mat << "\n";
}
}
}
Stages::const_iterator mi;
for (mi = _stages.begin(); mi != _stages.end(); ++mi) {
const StageList &stage_list = (*mi).first;
const GeomList &geom_list = (*mi).second;
// determine whether this texture needs a white or transparent background
bool use_transparent_bg = false;
if(stage_list.size() > 0) {
if(stage_list[0]._stage->get_mode() == TextureStage::M_decal)
use_transparent_bg = true;
else
use_transparent_bg = false;
}
grutil_cat.debug(false) << "use transparent bg = " << use_transparent_bg << "\n";
// Create an offscreen buffer in which to render the new texture.
// Start by choosing a model TextureStage to determine the new texture's
// properties.
const StageInfo &model_stage = stage_list[choose_model_stage(stage_list)];
Texture *model_tex = model_stage._tex;
int aniso_degree = model_tex->get_anisotropic_degree();
SamplerState::FilterType minfilter = model_tex->get_minfilter();
SamplerState::FilterType magfilter = model_tex->get_magfilter();
// What is the UV range of the model stage?
LTexCoord min_uv, max_uv;
determine_uv_range(min_uv, max_uv, model_stage, geom_list);
// Maybe we only use a small portion of the texture, or maybe we need to
// repeat the texture several times.
LVecBase2 uv_scale;
LVecBase2 uv_trans;
get_uv_scale(uv_scale, uv_trans, min_uv, max_uv);
// Also, if there is now a scale on the UV's (in conjunction with whatever
// texture matrix might be applied on the model stage), we may be able to
// adjust the image size accordingly, to keep the pixels at about the same
// scale--but we have to keep it to a power of 2.
int x_size;
int y_size;
choose_texture_size(x_size, y_size, model_stage, uv_scale,
window);
static int multitex_id = 1;
std::ostringstream multitex_name_strm;
multitex_name_strm << "multitex" << multitex_id;
multitex_id++;
GraphicsOutput *buffer = window->make_texture_buffer
(multitex_name_strm.str(), x_size, y_size, nullptr, false);
// TODO: this no longer automatically deletes the buffer. We need to take
// care of this explicitly now.
buffer->set_one_shot(true);
Texture *tex = buffer->get_texture();
tex->set_anisotropic_degree(aniso_degree);
tex->set_minfilter(minfilter);
tex->set_magfilter(magfilter);
// Set up the offscreen buffer to render 0,0 to 1,1. This will be the
// whole texture, but nothing outside the texture.
DisplayRegion *dr = buffer->make_display_region();
PT(Camera) cam_node = new Camera("multitexCam");
PT(Lens) lens = new OrthographicLens();
lens->set_film_size(1.0f, 1.0f);
lens->set_film_offset(0.5f, 0.5f);
lens->set_near_far(-1000.0f, 1000.0f);
lens->set_view_mat(LMatrix4(uv_scale[0], 0.0f, 0.0, 0.0f,
0.0f, 1.0f, 0.0, 0.0f,
0.0f, 0.0f, uv_scale[1], 0.0f,
uv_trans[0], 0.0f, uv_trans[1], 1.0f));
cam_node->set_lens(lens);
// Create a root node for the buffer's scene graph, and set up some
// appropriate properties for it.
NodePath render("buffer");
render.set_bin("unsorted", 0);
render.set_depth_test(false);
render.set_depth_write(false);
render.set_two_sided(1);
NodePath cam = render.attach_new_node(cam_node);
dr->set_camera(cam);
// If the geometry has vertex color and M_decal is in use, we must render
// with use_geom in effect. Otherwise we need not (and we might prefer
// not to).
bool force_use_geom = _use_geom;
bool bake_in_color = _use_geom;
LColor geom_color(1.0f, 1.0f, 1.0f, 1.0f);
// override the base color in the transparent pass down case.
if(use_transparent_bg)
geom_color = LColor(0.0f,0.0f,0.0f,0.0f);
if (!force_use_geom) {
bool uses_decal = scan_decal(stage_list);
if (uses_decal) {
// If we have M_decal, we need to bake in the flat color even if there
// is no vertex color.
bake_in_color = true;
/*
int num_colors = 0;
scan_color(geom_list, geom_color, num_colors);
if (num_colors > 1) {
// But if there is also vertex color, then we need to render with
// the geometry.
force_use_geom = true;
}*/
}
}
if (!force_use_geom) {
// Put one plain white (or flat-colored) card in the background for the
// first texture layer to apply onto.
CardMaker cm("background");
cm.set_frame(min_uv[0], max_uv[0], min_uv[1], max_uv[1]);
if (bake_in_color) {
cm.set_color(geom_color);
}
render.attach_new_node(cm.generate());
} else {
// Put a vertex-colored model of the geometry in the background for the
// first texture layer to apply only.
nassertv(bake_in_color);
PT(GeomNode) geom_node = new GeomNode("background");
transfer_geom(geom_node, nullptr, geom_list, true);
render.attach_new_node(geom_node);
}
StageList::const_iterator si;
for (si = stage_list.begin(); si != stage_list.end(); ++si) {
const StageInfo &stage_info = (*si);
make_texture_layer(render, stage_info, geom_list,
min_uv, max_uv, force_use_geom, use_transparent_bg);
}
// Now modify the geometry to apply the new texture, instead of the old
// multitexture.
CPT(RenderAttrib) new_ta = DCAST(TextureAttrib, TextureAttrib::make())->
add_on_stage(_target_stage, tex);
GeomList::const_iterator gi;
for (gi = geom_list.begin(); gi != geom_list.end(); ++gi) {
const GeomInfo &geom_info = (*gi);
CPT(RenderState) geom_state =
geom_info._geom_node->get_geom_state(geom_info._index);
int override = geom_info._geom_net_state->get_override(TextureAttrib::get_class_slot());
geom_state = geom_state->add_attrib(new_ta, override);
if (bake_in_color) {
// If we have baked the color into the texture, we have to be sure to
// disable coloring on the new fragment.
geom_state = geom_state->add_attrib(ColorAttrib::make_flat(LColor(1.0f, 1.0f, 1.0f, 1.0f)));
// And we invent a ColorScaleAttrib to undo the effect of any color
// scale we're getting from above. This is not the same thing as a
// ColorScaleAttrib::make_off(), since that would prohibit any future
// changes to the color scale.
const RenderAttrib *attrib =
geom_info._geom_net_state->get_attrib(ColorScaleAttrib::get_class_slot());
if (attrib != nullptr) {
geom_state = geom_state->add_attrib
(attrib->invert_compose(ColorScaleAttrib::make_identity()));
}
}
// Determine what tex matrix should be on the Geom.
CPT(TransformState) tex_mat = TransformState::make_identity();
const RenderAttrib *ra = geom_info._state->get_attrib(TexMatrixAttrib::get_class_slot());
if (ra != nullptr) {
// There is a texture matrix inherited from above; put an inverse
// matrix on the Geom to compensate.
const TexMatrixAttrib *tma = DCAST(TexMatrixAttrib, ra);
CPT(TransformState) tex_mat = tma->get_transform(_target_stage);
}
tex_mat = tex_mat->compose(TransformState::make_pos_hpr_scale
(LVecBase3(uv_trans[0], uv_trans[1], 0.0f),
LVecBase3(0.0f, 0.0f, 0.0f),
LVecBase3(uv_scale[0], uv_scale[1], 1.0f)));
if (tex_mat->is_identity()) {
// There should be no texture matrix on the Geom.
geom_state = geom_state->remove_attrib(TexMatrixAttrib::get_class_slot());
} else {
// The texture matrix should be as computed.
CPT(RenderAttrib) new_tma = TexMatrixAttrib::make
(_target_stage, tex_mat->invert_compose(TransformState::make_identity()));
geom_state = geom_state->add_attrib(new_tma);
}
geom_info._geom_node->set_geom_state(geom_info._index, geom_state);
}
}
// Now that we've copied all of the geometry and applied texture matrices,
// flatten out those texture matrices where possible.
GeomTransformer transformer;
GeomNodeList::const_iterator gni;
for (gni = _geom_node_list.begin(); gni != _geom_node_list.end(); ++gni) {
const GeomNodeInfo &geom_node_info = (*gni);
AccumulatedAttribs attribs;
attribs._texture =
geom_node_info._state->get_attrib(TextureAttrib::get_class_slot());
geom_node_info._geom_node->apply_attribs_to_vertices
(attribs, SceneGraphReducer::TT_tex_matrix, transformer);
}
}
/**
* Adds the Geoms in the indicated GeomNode to the internal database of
* multitexture elements.
*/
void MultitexReducer::
scan_geom_node(GeomNode *node, const RenderState *state,
const TransformState *transform) {
if (grutil_cat.is_debug()) {
grutil_cat.debug()
<< "scan_geom_node(" << *node << ", " << *state << ", "
<< *transform << ")\n";
}
_geom_node_list.push_back(GeomNodeInfo(state, node));
int num_geoms = node->get_num_geoms();
for (int gi = 0; gi < num_geoms; gi++) {
CPT(RenderState) geom_net_state =
state->compose(node->get_geom_state(gi));
if (grutil_cat.is_debug()) {
grutil_cat.debug()
<< "geom " << gi << " net_state =\n";
geom_net_state->write(std::cerr, 2);
}
// Get out the net TextureAttrib and TexMatrixAttrib from the state.
const RenderAttrib *attrib;
const TextureAttrib *ta = nullptr;
attrib = geom_net_state->get_attrib(TextureAttrib::get_class_slot());
if (attrib != nullptr) {
ta = DCAST(TextureAttrib, attrib);
}
if (ta == nullptr) {
// No texture should be on the Geom.
CPT(RenderState) geom_state = node->get_geom_state(gi);
geom_state = geom_state->remove_attrib(TextureAttrib::get_class_slot());
node->set_geom_state(gi, geom_state);
} else if (ta->get_num_on_stages() < 2) {
// Just a single texture on the Geom; we don't really need to do
// anything to flatten the textures, then. But we should ensure that
// the correct TextureAttrib is applied to the Geom.
int override = geom_net_state->get_override(TextureAttrib::get_class_slot());
CPT(RenderState) geom_state = node->get_geom_state(gi);
geom_state = geom_state->add_attrib(ta, override);
node->set_geom_state(gi, geom_state);
} else {
// Ok, we have multitexture. Record the Geom.
CPT(TexMatrixAttrib) tma = DCAST(TexMatrixAttrib, TexMatrixAttrib::make());
attrib = geom_net_state->get_attrib(TexMatrixAttrib::get_class_slot());
if (attrib != nullptr) {
tma = DCAST(TexMatrixAttrib, attrib);
}
StageList stage_list;
int num_stages = ta->get_num_on_stages();
for (int si = 0; si < num_stages; si++) {
TextureStage *stage = ta->get_on_stage(si);
Texture *tex = ta->get_on_texture(stage);
if (tex->get_x_size() != 0 && tex->get_y_size() != 0) {
stage_list.push_back(StageInfo(stage, ta, tma));
} else {
grutil_cat.info()
<< "Ignoring invalid texture stage " << stage->get_name() << "\n";
}
}
if (stage_list.size() >= 2) {
record_stage_list(stage_list, GeomInfo(state, geom_net_state, node, gi));
}
}
}
}
/**
* Adds the record of this one Geom and its associated StageList.
*/
void MultitexReducer::
record_stage_list(const MultitexReducer::StageList &stage_list,
const MultitexReducer::GeomInfo &geom_info) {
if (grutil_cat.is_debug()) {
grutil_cat.debug()
<< "record_stage_list for " << geom_info._geom_node->get_name() << " g"
<< geom_info._index << ":\n";
StageList::const_iterator si;
for (si = stage_list.begin(); si != stage_list.end(); ++si) {
const StageInfo &stage_info = (*si);
grutil_cat.debug(false)
<< " " << *stage_info._stage << " " << *stage_info._tex
<< " " << *stage_info._tex_mat << "\n";
}
}
_stages[stage_list].push_back(geom_info);
}
/**
* Chooses one of the TextureStages in the stage_list to serve as the model to
* determine the size and properties of the resulting texture.
*/
size_t MultitexReducer::
choose_model_stage(const MultitexReducer::StageList &stage_list) const {
for (size_t si = 0; si < stage_list.size(); si++) {
const StageInfo &stage_info = stage_list[si];
if (stage_info._stage == _target_stage) {
// If we find the target stage, use that.
return si;
}
}
// If none of the stages are the target stage, use the bottom image.
return 0;
}
/**
* Determines what the effective UV range for the indicated texture is across
* its geoms. Returns true if any UV's are found, false otherwise.
*/
bool MultitexReducer::
determine_uv_range(LTexCoord &min_uv, LTexCoord &max_uv,
const MultitexReducer::StageInfo &model_stage,
const MultitexReducer::GeomList &geom_list) const {
const InternalName *model_name = model_stage._stage->get_texcoord_name();
bool got_any = false;
GeomList::const_iterator gi;
for (gi = geom_list.begin(); gi != geom_list.end(); ++gi) {
const GeomInfo &geom_info = (*gi);
PT(Geom) geom =
geom_info._geom_node->get_geom(geom_info._index)->make_copy();
CPT(GeomVertexData) vdata = geom->get_vertex_data();
CPT(GeomVertexFormat) format = vdata->get_format();
if (format->has_column(model_name)) {
GeomVertexReader texcoord(vdata, model_name);
if (!texcoord.is_at_end()) {
const LVecBase2 &uv = texcoord.get_data2();
if (!got_any) {
min_uv = max_uv = uv;
got_any = true;
} else {
min_uv.set(min(min_uv[0], uv[0]), min(min_uv[1], uv[1]));
max_uv.set(max(max_uv[0], uv[0]), max(max_uv[1], uv[1]));
}
while (!texcoord.is_at_end()) {
const LVecBase2 &uv = texcoord.get_data2();
min_uv.set(min(min_uv[0], uv[0]), min(min_uv[1], uv[1]));
max_uv.set(max(max_uv[0], uv[0]), max(max_uv[1], uv[1]));
}
}
}
}
if (!got_any) {
min_uv.set(0.0f, 0.0f);
max_uv.set(1.0f, 1.0f);
}
return got_any;
}
/**
* Chooses an appropriate transform to apply to all of the UV's on the
* generated texture, based on the coverage of the model stage. If only a
* portion of the model stage is used, we scale the UV's up to zoom into that
* one portion; on the other hand, if the texture repeats many times, we scale
* the UV's down to to include all of the repeating image.
*/
void MultitexReducer::
get_uv_scale(LVecBase2 &uv_scale, LVecBase2 &uv_trans,
const LTexCoord &min_uv, const LTexCoord &max_uv) const {
if (max_uv[0] != min_uv[0]) {
uv_scale[0] = (max_uv[0] - min_uv[0]);
} else {
uv_scale[0] = 1.0f;
}
if (max_uv[1] != min_uv[1]) {
uv_scale[1] = (max_uv[1] - min_uv[1]);
} else {
uv_scale[1] = 1.0f;
}
uv_trans[0] = (min_uv[0] + max_uv[0]) / 2.0f - uv_scale[0] * 0.5f;
uv_trans[1] = (min_uv[1] + max_uv[1]) / 2.0f - uv_scale[1] * 0.5f;
}
/**
* Chooses an appropriate size to make the new texture, based on the size of
* the original model stage's texture, and the scale applied to the UV's.
*/
void MultitexReducer::
choose_texture_size(int &x_size, int &y_size,
const MultitexReducer::StageInfo &model_stage,
const LVecBase2 &uv_scale,
GraphicsOutput *window) const {
Texture *model_tex = model_stage._tex;
// Start with the same size as the model texture.
x_size = model_tex->get_x_size();
y_size = model_tex->get_y_size();
// But we might be looking at just a subset of that texture (|scale| < 1) or
// a superset of the texture (|scale| > 1). In this case, we should adjust
// the pixel size accordingly, although we have to keep it to a power of 2.
LVecBase3 inherited_scale = model_stage._tex_mat->get_scale();
PN_stdfloat u_scale = cabs(inherited_scale[0]) * uv_scale[0];
if (u_scale != 0.0f) {
while (u_scale >= 2.0f) {
x_size *= 2;
u_scale *= 0.5f;
}
while (u_scale <= 0.5f && x_size > 0) {
x_size /= 2;
u_scale *= 2.0f;
}
}
PN_stdfloat v_scale = cabs(inherited_scale[1]) * uv_scale[1];
if (v_scale != 0.0f) {
while (v_scale >= 2.0f) {
y_size *= 2;
v_scale *= 0.5f;
}
while (v_scale <= 0.5f && y_size > 0) {
y_size /= 2;
v_scale *= 2.0f;
}
}
if (x_size == 0 || y_size == 0) {
grutil_cat.warning()
<< "Texture size " << model_tex->get_x_size() << " "
<< model_tex->get_y_size() << " with scale "
<< model_stage._tex_mat->get_scale() << ", reduced to size "
<< x_size << " " << y_size << "; constraining to 1 1.\n";
x_size = 1;
y_size = 1;
}
// Constrain the x_size and y_size to the max_texture_dimension.
if (max_texture_dimension > 0) {
x_size = min(x_size, (int)max_texture_dimension);
y_size = min(y_size, (int)max_texture_dimension);
}
// Finally, make sure the new sizes fit within the window, so we can use a
// parasite buffer.
int win_x_size = window->get_x_size();
if (win_x_size != 0 && x_size > win_x_size) {
x_size /= 2;
while (x_size > win_x_size) {
x_size /= 2;
}
}
int win_y_size = window->get_y_size();
if (win_y_size != 0 && y_size > win_y_size) {
y_size /= 2;
while (y_size > win_y_size) {
y_size /= 2;
}
}
}
/**
* Creates geometry to render the texture into the offscreen buffer using the
* same effects that were requested by its multitexture specification.
*/
void MultitexReducer::
make_texture_layer(const NodePath &render,
const MultitexReducer::StageInfo &stage_info,
const MultitexReducer::GeomList &geom_list,
const LTexCoord &min_uv, const LTexCoord &max_uv,
bool force_use_geom, bool transparent_base) {
CPT(RenderAttrib) cba;
switch (stage_info._stage->get_mode()) {
case TextureStage::M_normal:
case TextureStage::M_normal_height:
case TextureStage::M_glow:
case TextureStage::M_gloss:
case TextureStage::M_height:
case TextureStage::M_selector:
case TextureStage::M_normal_gloss:
// Don't know what to do with these funny modes. We should probably raise
// an exception or something. Fall through for now.
case TextureStage::M_modulate_glow:
case TextureStage::M_modulate_gloss:
case TextureStage::M_modulate:
cba = ColorBlendAttrib::make
(ColorBlendAttrib::M_add, ColorBlendAttrib::O_fbuffer_color,
ColorBlendAttrib::O_zero);
break;
case TextureStage::M_decal:
if(transparent_base) {
cba = AlphaTestAttrib::make
(AlphaTestAttrib::M_greater, 0.0f);
} else {
cba = ColorBlendAttrib::make
(ColorBlendAttrib::M_add, ColorBlendAttrib::O_incoming_alpha,
ColorBlendAttrib::O_one_minus_incoming_alpha);
}
break;
case TextureStage::M_blend:
cba = ColorBlendAttrib::make
(ColorBlendAttrib::M_add, ColorBlendAttrib::O_constant_color,
ColorBlendAttrib::O_one_minus_incoming_color,
stage_info._stage->get_color());
break;
case TextureStage::M_replace:
cba = ColorBlendAttrib::make_off();
break;
case TextureStage::M_add:
cba = ColorBlendAttrib::make
(ColorBlendAttrib::M_add, ColorBlendAttrib::O_one,
ColorBlendAttrib::O_one);
break;
case TextureStage::M_combine:
// We only support certain modes of M_combine.
switch (stage_info._stage->get_combine_rgb_mode()) {
case TextureStage::CM_modulate:
{
TextureStage::CombineSource source0 = stage_info._stage->get_combine_rgb_source0();
TextureStage::CombineSource source1 = stage_info._stage->get_combine_rgb_source1();
// Since modulate doesn't care about order, let's establish the
// convention that the lowest-numbered source operand is in slot 0
// (just for purposes of comparison).
if (source1 < source0) {
source0 = stage_info._stage->get_combine_rgb_source1();
source1 = stage_info._stage->get_combine_rgb_source0();
}
if (source0 == TextureStage::CS_primary_color &&
source1 == TextureStage::CS_previous) {
// This is just a trick to re-apply the vertex (lighting) color on
// the top of the texture stack. We can ignore it, since the
// flattened texture will do this anyway.
return;
} else if (source0 == TextureStage::CS_texture &&
source1 == TextureStage::CS_constant) {
// Scaling the texture by a flat color.
cba = ColorBlendAttrib::make
(ColorBlendAttrib::M_add, ColorBlendAttrib::O_constant_color,
ColorBlendAttrib::O_zero, stage_info._stage->get_color());
} else if (source0 == TextureStage::CS_texture &&
source1 == TextureStage::CS_previous) {
// Just an ordinary modulate.
cba = ColorBlendAttrib::make
(ColorBlendAttrib::M_add, ColorBlendAttrib::O_fbuffer_color,
ColorBlendAttrib::O_zero);
} else {
// Some other kind of modulate; we don't support it.
return;
}
}
break;
default:
// Ignore this stage; we don't support it.
return;
}
break;
case TextureStage::M_blend_color_scale:
// TODO: make a distinction between this and M_blend.
cba = ColorBlendAttrib::make
(ColorBlendAttrib::M_add, ColorBlendAttrib::O_constant_color,
ColorBlendAttrib::O_one_minus_incoming_color,
stage_info._stage->get_color());
break;
}
NodePath geom;
if (!force_use_geom && stage_info._stage->get_texcoord_name() == _target_stage->get_texcoord_name()) {
// If this TextureStage uses the target texcoords, we can just generate a
// simple card the fills the entire buffer.
CardMaker cm(stage_info._tex->get_name());
cm.set_uv_range(min_uv, max_uv);
cm.set_has_uvs(true);
cm.set_frame(min_uv[0], max_uv[0], min_uv[1], max_uv[1]);
geom = render.attach_new_node(cm.generate());
} else {
// If this TextureStage uses some other texcoords (or if use_geom is
// true), we have to generate geometry that maps the texcoords to the
// target space. This will work only for very simple cases where the
// geometry is not too extensive and doesn't repeat over the same UV's.
PT(GeomNode) geom_node = new GeomNode(stage_info._tex->get_name());
transfer_geom(geom_node, stage_info._stage->get_texcoord_name(),
geom_list, false);
geom = render.attach_new_node(geom_node);
geom.set_color(LColor(1.0f, 1.0f, 1.0f, 1.0f));
}
if (!stage_info._tex_mat->is_identity()) {
geom.set_tex_transform(TextureStage::get_default(), stage_info._tex_mat);
}
geom.set_texture(stage_info._tex);
geom.node()->set_attrib(cba);
}
/**
* Copy the vertices from the indicated geom_list, mapping the vertex
* coordinates so that the geometry will render the appropriate distortion on
* the texture to map UV's from the specified set of texture coordinates to
* the target set.
*/
void MultitexReducer::
transfer_geom(GeomNode *geom_node, const InternalName *texcoord_name,
const MultitexReducer::GeomList &geom_list,
bool preserve_color) {
Thread *current_thread = Thread::get_current_thread();
GeomList::const_iterator gi;
for (gi = geom_list.begin(); gi != geom_list.end(); ++gi) {
const GeomInfo &geom_info = (*gi);
const Geom *orig_geom = geom_info._geom_node->get_geom(geom_info._index);
// Copy the Geom. This actually performs just a pointer copy of the
// original GeomVertexData and other associated structures.
PT(Geom) geom = orig_geom->make_copy();
// Ensure that any vertex animation has been applied.
geom->set_vertex_data(geom->get_animated_vertex_data(true, current_thread));
// Now get a modifiable pointer to the vertex data in the new Geom. This
// will actually perform a deep copy of the vertex data.
PT(GeomVertexData) vdata = geom->modify_vertex_data();
vdata->set_usage_hint(Geom::UH_stream);
if (vdata->has_column(_target_stage->get_texcoord_name())) {
GeomVertexWriter vertex(vdata, InternalName::get_vertex(), current_thread);
GeomVertexReader texcoord(vdata, _target_stage->get_texcoord_name(), current_thread);
while (!texcoord.is_at_end()) {
const LVecBase2 &tc = texcoord.get_data2();
vertex.set_data3(tc[0], 0.0f, tc[1]);
}
}
if (texcoord_name != nullptr &&
texcoord_name != InternalName::get_texcoord()) {
// Copy the texture coordinates from the indicated name over to the
// default name.
const GeomVertexColumn *column =
vdata->get_format()->get_column(texcoord_name);
if (column != nullptr) {
vdata = vdata->replace_column
(InternalName::get_texcoord(), column->get_num_components(),
column->get_numeric_type(), column->get_contents());
geom->set_vertex_data(vdata);
GeomVertexReader from(vdata, texcoord_name, current_thread);
GeomVertexWriter to(vdata, InternalName::get_texcoord(), current_thread);
while (!from.is_at_end()) {
to.add_data2(from.get_data2());
}
}
}
CPT(RenderState) geom_state = RenderState::make_empty();
if (preserve_color) {
// Be sure to preserve whatever colors are on the geom.
const RenderAttrib *ca = geom_info._geom_net_state->get_attrib(ColorAttrib::get_class_slot());
if (ca != nullptr) {
geom_state = geom_state->add_attrib(ca);
}
const RenderAttrib *csa = geom_info._geom_net_state->get_attrib(ColorScaleAttrib::get_class_slot());
if (csa != nullptr) {
geom_state = geom_state->add_attrib(csa);
}
}
geom_node->add_geom(geom, geom_state);
}
}
/**
* Checks all the geoms in the list to see if they all use flat color, or if
* there is per-vertex color in use.
*
* Assumption: num_colors = 0 on entry. On exit, num_colors = 1 if there is
* exactly one color in use, or 2 if there is more than one color in use. If
* num_colors = 1, then geom_color is filled in with the color in use.
*/
void MultitexReducer::
scan_color(const MultitexReducer::GeomList &geom_list, LColor &geom_color,
int &num_colors) const {
GeomList::const_iterator gi;
for (gi = geom_list.begin(); gi != geom_list.end() && num_colors < 2; ++gi) {
const GeomInfo &geom_info = (*gi);
LColor flat_color;
bool has_flat_color = false;
bool has_vertex_color = false;
LColor color_scale(1.0f, 1.0f, 1.0f, 1.0f);
const RenderAttrib *csa = geom_info._geom_net_state->get_attrib(ColorScaleAttrib::get_class_slot());
if (csa != nullptr) {
const ColorScaleAttrib *a = DCAST(ColorScaleAttrib, csa);
if (a->has_scale()) {
color_scale = a->get_scale();
}
}
ColorAttrib::Type color_type = ColorAttrib::T_vertex;
const RenderAttrib *ca = geom_info._geom_net_state->get_attrib(ColorAttrib::get_class_slot());
if (ca != nullptr) {
color_type = DCAST(ColorAttrib, ca)->get_color_type();
}
if (color_type == ColorAttrib::T_flat) {
// This geom has a flat color attrib, which overrides the vertices.
flat_color = DCAST(ColorAttrib, ca)->get_color();
has_flat_color = true;
} else if (color_type == ColorAttrib::T_vertex) {
// This geom gets its color from its vertices.
const Geom *geom = geom_info._geom_node->get_geom(geom_info._index);
if (geom->get_vertex_data()->has_column(InternalName::get_color())) {
// This geom has per-vertex color. Assume the colors in the table are
// actually different from each other.
has_vertex_color = true;
}
}
if (has_vertex_color) {
num_colors = 2;
} else if (has_flat_color) {
flat_color.set(flat_color[0] * color_scale[0],
flat_color[1] * color_scale[1],
flat_color[2] * color_scale[2],
flat_color[3] * color_scale[3]);
if (num_colors == 0) {
num_colors = 1;
geom_color = flat_color;
} else if (!flat_color.almost_equal(geom_color)) {
// Too bad; there are multiple colors.
num_colors = 2;
}
}
}
}
/**
* Checks all the stages in the list to see if any of them apply a texture via
* M_decal. Returns true if so, false otherwise.
*/
bool MultitexReducer::
scan_decal(const MultitexReducer::StageList &stage_list) const {
StageList::const_iterator si;
for (si = stage_list.begin(); si != stage_list.end(); ++si) {
const StageInfo &stage_info = (*si);
if (stage_info._stage->get_mode() == TextureStage::M_decal) {
return true;
}
}
return false;
}
/**
*
*/
MultitexReducer::StageInfo::
StageInfo(TextureStage *stage, const TextureAttrib *ta,
const TexMatrixAttrib *tma) :
_stage(stage),
_tex_mat(TransformState::make_identity())
{
_tex = ta->get_on_texture(_stage);
if (tma->has_stage(stage)) {
_tex_mat = tma->get_transform(stage);
}
}
Reference in New Issue View Git Blame Copy Permalink