bool initializeRenderingResources(Renderer* pRenderer, RenderTarget* pRenderTarget)
{
// SHADER
//----------------------------------------------------------------------------------------------------------------
ShaderLoadDesc paniniPass = {};
paniniPass.mStages[0] = { "panini_projection.vert", NULL, 0, FSR_SrcShaders_Common };
paniniPass.mStages[1] = { "panini_projection.frag", NULL, 0, FSR_SrcShaders_Common };
addShader(pRenderer, &paniniPass, &pShaderPanini);
// SAMPLERS & STATES
//----------------------------------------------------------------------------------------------------------------
addSampler(pRenderer, &pSamplerTrilinearAniso, FILTER_TRILINEAR_ANISO, FILTER_BILINEAR, MIPMAP_MODE_LINEAR, ADDRESS_MODE_REPEAT, ADDRESS_MODE_REPEAT, ADDRESS_MODE_REPEAT, 0.0f, 8.0f);
addRasterizerState(&pRasterizerStateCullNone, CULL_MODE_NONE);
addDepthState(pRenderer, &pDepthStateDisable, false, false);
// ROOT SIGNATURE
//----------------------------------------------------------------------------------------------------------------
RootSignatureDesc paninniRootDesc = {};
paninniRootDesc.mStaticSamplers["uSampler"] = pSamplerTrilinearAniso;
addRootSignature(pRenderer, 1, &pShaderPanini, &pRootSignaturePaniniPostProcess, &paninniRootDesc);
// PIPELINE
//----------------------------------------------------------------------------------------------------------------
VertexLayout vertexLayoutPanini = {};
vertexLayoutPanini.mAttribCount = 1;
vertexLayoutPanini.mAttribs[0].mSemantic = SEMANTIC_POSITION;
vertexLayoutPanini.mAttribs[0].mFormat = ImageFormat::RGBA32F;
vertexLayoutPanini.mAttribs[0].mBinding = 0;
vertexLayoutPanini.mAttribs[0].mLocation = 0;
vertexLayoutPanini.mAttribs[0].mOffset = 0;
GraphicsPipelineDesc pipelineSettings = { 0 };
pipelineSettings.mPrimitiveTopo = PRIMITIVE_TOPO_TRI_LIST;
pipelineSettings.mRenderTargetCount = 1;
pipelineSettings.pDepthState = pDepthStateDisable;
pipelineSettings.pColorFormats = &pRenderTarget->mDesc.mFormat;
pipelineSettings.pSrgbValues = &pRenderTarget->mDesc.mSrgb;
pipelineSettings.mSampleCount = pRenderTarget->mDesc.mSampleCount;
pipelineSettings.mSampleQuality = pRenderTarget->mDesc.mSampleQuality;
pipelineSettings.pRasterizerState = pRasterizerStateCullNone;
pipelineSettings.pRootSignature = pRootSignaturePaniniPostProcess;
pipelineSettings.pShaderProgram = pShaderPanini;
pipelineSettings.pVertexLayout = &vertexLayoutPanini;
addPipeline(pRenderer, &pipelineSettings, &pPipielinePaniniPostProcess);
createTessellatedQuadBuffers(&pVertexBufferTessellatedQuad, &pIndexBufferTessellatedQuad, gPaniniDistortionTessellation[0], gPaniniDistortionTessellation[1]);
#if USE_DEDICATED_COMMAND_LIST
// COMMAND LIST
//----------------------------------------------------------------------------------------------------------------
addCmdPool(pRenderer, pGraphicsQueue, false, &pPaniniCmdPool);
addCmd_n(pPaniniCmdPool, false, imageCount, &ppPaniniCmds);
#endif
return true;
}
//parse a config file and generate a Renderer
Renderer* ConfigParser::parse(std::string filename){
std::cout << "ConfigParser::parse config file... " << filename <<" \n";
struct basicxmlnode * rootNode = NULL;
//open file
FILE * fp = fopen(filename.c_str(), "rt");
if (!fp) {
std::cerr << "ConfigParser - Error: Failed opening file " << filename << "\n";
return NULL;
}
rootNode = readbasicxmlnode(fp);
fclose(fp);
if (!rootNode) {
std::cerr << "ConfigParser - Error: Failed reading file " << filename << ". Maybe an XML syntax error?\n";
return NULL;
}
//create renderer
Renderer* renderer = new Renderer();
//read renderer properties
if (!addRendererProperties(rootNode, renderer)) {
std::cerr << "ConfigParser - Error: Failed reading renderer properties in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(renderer);
return NULL;
}
//read sampler
struct basicxmlnode * samplerNode = getchildnodebyname(rootNode, "Sampler");
if (!addSampler(samplerNode, renderer)) {
std::cerr << "ConfigParser - Error: Failed reading sampler description in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(renderer);
return NULL;
}
//read shader
struct basicxmlnode * shaderNode = getchildnodebyname(rootNode, "Shader");
if (!addShader(shaderNode, renderer)) {
std::cerr << "ConfigParser - Error: Failed reading shader description in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(renderer);
return NULL;
}
//free xml memory
deletebasicxmlnode(rootNode);
std::cout << "[done]\n\n";
return renderer;
}
// dae_bone_animation -> add_bone_animation
// (blend this into dae_bone_animation)
void AnimationExporter::dae_bone_animation(std::vector<float> &fra, float *values, int tm_type, int axis, std::string ob_name, std::string bone_name)
{
const char *axis_names[] = {"X", "Y", "Z"};
const char *axis_name = NULL;
char anim_id[200];
bool is_rot = tm_type == 0;
if (!fra.size())
return;
char rna_path[200];
BLI_snprintf(rna_path, sizeof(rna_path), "pose.bones[\"%s\"].%s", bone_name.c_str(),
tm_type == 0 ? "rotation_quaternion" : (tm_type == 1 ? "scale" : "location"));
if (axis > -1)
axis_name = axis_names[axis];
std::string transform_sid = get_transform_sid(NULL, tm_type, axis_name, false);
BLI_snprintf(anim_id, sizeof(anim_id), "%s_%s_%s", (char *)translate_id(ob_name).c_str(),
(char *)translate_id(bone_name).c_str(), (char *)transform_sid.c_str());
openAnimation(anim_id, COLLADABU::Utils::EMPTY_STRING);
// create input source
std::string input_id = create_source_from_vector(COLLADASW::InputSemantic::INPUT, fra, is_rot, anim_id, axis_name);
// create output source
std::string output_id;
if (axis == -1)
output_id = create_xyz_source(values, fra.size(), anim_id);
else
output_id = create_source_from_array(COLLADASW::InputSemantic::OUTPUT, values, fra.size(), is_rot, anim_id, axis_name);
// create interpolations source
std::string interpolation_id = fake_interpolation_source(fra.size(), anim_id, axis_name);
std::string sampler_id = std::string(anim_id) + SAMPLER_ID_SUFFIX;
COLLADASW::LibraryAnimations::Sampler sampler(sw, sampler_id);
std::string empty;
sampler.addInput(COLLADASW::InputSemantic::INPUT, COLLADABU::URI(empty, input_id));
sampler.addInput(COLLADASW::InputSemantic::OUTPUT, COLLADABU::URI(empty, output_id));
// TODO create in/out tangents source
// this input is required
sampler.addInput(COLLADASW::InputSemantic::INTERPOLATION, COLLADABU::URI(empty, interpolation_id));
addSampler(sampler);
std::string target = translate_id(ob_name + "_" + bone_name) + "/" + transform_sid;
addChannel(COLLADABU::URI(empty, sampler_id), target);
closeAnimation();
}
void AnimationExporter::dae_baked_animation(std::vector<float> &fra, Object *ob_arm, Bone *bone)
{
std::string ob_name = id_name(ob_arm);
std::string bone_name = bone->name;
char anim_id[200];
if (!fra.size())
return;
BLI_snprintf(anim_id, sizeof(anim_id), "%s_%s_%s", (char *)translate_id(ob_name).c_str(),
(char *)translate_id(bone_name).c_str(), "pose_matrix");
openAnimation(anim_id, COLLADABU::Utils::EMPTY_STRING);
// create input source
std::string input_id = create_source_from_vector(COLLADASW::InputSemantic::INPUT, fra, false, anim_id, "");
// create output source
std::string output_id;
output_id = create_4x4_source(fra, ob_arm, bone, anim_id);
// create interpolations source
std::string interpolation_id = fake_interpolation_source(fra.size(), anim_id, "");
std::string sampler_id = std::string(anim_id) + SAMPLER_ID_SUFFIX;
COLLADASW::LibraryAnimations::Sampler sampler(sw, sampler_id);
std::string empty;
sampler.addInput(COLLADASW::InputSemantic::INPUT, COLLADABU::URI(empty, input_id));
sampler.addInput(COLLADASW::InputSemantic::OUTPUT, COLLADABU::URI(empty, output_id));
// TODO create in/out tangents source
// this input is required
sampler.addInput(COLLADASW::InputSemantic::INTERPOLATION, COLLADABU::URI(empty, interpolation_id));
addSampler(sampler);
std::string target = translate_id(bone_name) + "/transform";
addChannel(COLLADABU::URI(empty, sampler_id), target);
closeAnimation();
}
void App::startRecording()
{
if (verbose_)
std::cout << __FUNCTION__ << std::endl;
if (recording_)
{
std::cerr << "Already recording." << std::endl;
return;
}
//current_ = addSampler();
addSampler();
Sampler *current = getCurrentlyRecordingSampler();
if (current)
{
current->setColor(color_.red, color_.green, color_.blue);
current->startRecording();
recording_ = true;
}
}
//convert f-curves to animation curves and write
void AnimationExporter::dae_animation(Object *ob, FCurve *fcu, char *transformName, bool is_param, Material *ma)
{
const char *axis_name = NULL;
char anim_id[200];
bool has_tangents = false;
bool quatRotation = false;
if (!strcmp(transformName, "rotation_quaternion") ) {
fprintf(stderr, "quaternion rotation curves are not supported. rotation curve will not be exported\n");
quatRotation = true;
return;
}
//axis names for colors
else if (!strcmp(transformName, "color") || !strcmp(transformName, "specular_color") || !strcmp(transformName, "diffuse_color") ||
(!strcmp(transformName, "alpha")))
{
const char *axis_names[] = {"R", "G", "B"};
if (fcu->array_index < 3)
axis_name = axis_names[fcu->array_index];
}
//axis names for transforms
else if ((!strcmp(transformName, "location") || !strcmp(transformName, "scale")) ||
(!strcmp(transformName, "rotation_euler")) || (!strcmp(transformName, "rotation_quaternion")))
{
const char *axis_names[] = {"X", "Y", "Z"};
if (fcu->array_index < 3)
axis_name = axis_names[fcu->array_index];
}
else {
/* no axis name. single parameter */
axis_name = "";
}
std::string ob_name = std::string("null");
//Create anim Id
if (ob->type == OB_ARMATURE) {
ob_name = getObjectBoneName(ob, fcu);
BLI_snprintf(anim_id, sizeof(anim_id), "%s_%s.%s", (char *)translate_id(ob_name).c_str(),
transformName, axis_name);
}
else {
if (ma)
ob_name = id_name(ob) + "_material";
else
ob_name = id_name(ob);
BLI_snprintf(anim_id, sizeof(anim_id), "%s_%s_%s", (char *)translate_id(ob_name).c_str(),
fcu->rna_path, axis_name);
}
openAnimation(anim_id, COLLADABU::Utils::EMPTY_STRING);
// create input source
std::string input_id = create_source_from_fcurve(COLLADASW::InputSemantic::INPUT, fcu, anim_id, axis_name);
// create output source
std::string output_id;
//quat rotations are skipped for now, because of complications with determining axis.
if (quatRotation) {
float *eul = get_eul_source_for_quat(ob);
float *eul_axis = (float *)MEM_callocN(sizeof(float) * fcu->totvert, "quat output source values");
for (int i = 0; i < fcu->totvert; i++) {
eul_axis[i] = eul[i * 3 + fcu->array_index];
}
output_id = create_source_from_array(COLLADASW::InputSemantic::OUTPUT, eul_axis, fcu->totvert, quatRotation, anim_id, axis_name);
MEM_freeN(eul);
MEM_freeN(eul_axis);
}
else {
output_id = create_source_from_fcurve(COLLADASW::InputSemantic::OUTPUT, fcu, anim_id, axis_name);
}
// create interpolations source
std::string interpolation_id = create_interpolation_source(fcu, anim_id, axis_name, &has_tangents);
// handle tangents (if required)
std::string intangent_id;
std::string outtangent_id;
if (has_tangents) {
// create in_tangent source
intangent_id = create_source_from_fcurve(COLLADASW::InputSemantic::IN_TANGENT, fcu, anim_id, axis_name);
// create out_tangent source
outtangent_id = create_source_from_fcurve(COLLADASW::InputSemantic::OUT_TANGENT, fcu, anim_id, axis_name);
}
std::string sampler_id = std::string(anim_id) + SAMPLER_ID_SUFFIX;
COLLADASW::LibraryAnimations::Sampler sampler(sw, sampler_id);
std::string empty;
sampler.addInput(COLLADASW::InputSemantic::INPUT, COLLADABU::URI(empty, input_id));
sampler.addInput(COLLADASW::InputSemantic::OUTPUT, COLLADABU::URI(empty, output_id));
// this input is required
sampler.addInput(COLLADASW::InputSemantic::INTERPOLATION, COLLADABU::URI(empty, interpolation_id));
if (has_tangents) {
sampler.addInput(COLLADASW::InputSemantic::IN_TANGENT, COLLADABU::URI(empty, intangent_id));
sampler.addInput(COLLADASW::InputSemantic::OUT_TANGENT, COLLADABU::URI(empty, outtangent_id));
}
addSampler(sampler);
std::string target;
if (!is_param)
target = translate_id(ob_name) +
"/" + get_transform_sid(fcu->rna_path, -1, axis_name, true);
else {
if (ob->type == OB_LAMP)
target = get_light_id(ob) +
"/" + get_light_param_sid(fcu->rna_path, -1, axis_name, true);
if (ob->type == OB_CAMERA)
target = get_camera_id(ob) +
"/" + get_camera_param_sid(fcu->rna_path, -1, axis_name, true);
if (ma)
target = translate_id(id_name(ma)) + "-effect" +
"/common/" /*profile common is only supported */ + get_transform_sid(fcu->rna_path, -1, axis_name, true);
}
addChannel(COLLADABU::URI(empty, sampler_id), target);
closeAnimation();
}