void LightingParser_ResolveGBuffer(
Metal::DeviceContext& context, LightingParserContext& parserContext,
MainTargetsBox& mainTargets, LightingResolveTextureBox& lightingResTargets)
{
Metal::GPUProfiler::DebugAnnotation anno(context, L"ResolveGBuffer");
const bool doSampleFrequencyOptimisation = Tweakable("SampleFrequencyOptimisation", true);
LightingResolveContext lightingResolveContext(mainTargets);
const unsigned samplingCount = lightingResolveContext.GetSamplingCount();
const bool useMsaaSamplers = lightingResolveContext.UseMsaaSamplers();
auto& resolveRes = Techniques::FindCachedBoxDep2<LightingResolveResources>(samplingCount);
//
// Our inputs is the prepared gbuffer
// -- we resolve the lighting and write out a "lighting resolve texture"
//
if (doSampleFrequencyOptimisation && samplingCount>1) {
context.Bind(resolveRes._alwaysWriteToStencil, 0xff);
// todo -- instead of clearing the stencil every time, how
// about doing a progressive walk through all of the bits!
context.ClearStencil(mainTargets._secondaryDepthBuffer, 0);
context.Bind(ResourceList<Metal::RenderTargetView, 0>(), &mainTargets._secondaryDepthBuffer);
context.BindPS(MakeResourceList(mainTargets._msaaDepthBufferSRV, mainTargets._gbufferRTVsSRV[1]));
SetupVertexGeneratorShader(context);
CATCH_ASSETS_BEGIN
context.Bind(*resolveRes._perSampleMask);
context.Draw(4);
CATCH_ASSETS_END(parserContext)
}
DataProviderDTang<Dtype>::DataProviderDTang(const pose::DataProviderParameter& param) : DataProvider<Dtype>(param) {
std::cout << "[INFO] read label file " << param.dtang_param().label_path() << std::endl;
boost::filesystem::path label_path = param.dtang_param().label_path();
std::ifstream label_file(label_path.c_str());
std::string line;
int idx = 0;
while(std::getline(label_file, line)) {
std::istringstream iss(line);
std::string relative_depth_path;
iss >> relative_depth_path;
boost::filesystem::path depth_path = label_path.parent_path() / "Depth" /
boost::filesystem::path(relative_depth_path);
std::vector<cv::Vec3f> anno(param.n_pts());
for(int pt_idx = 0; pt_idx < anno.size(); ++pt_idx) {
iss >> anno[pt_idx](0);
iss >> anno[pt_idx](1);
iss >> anno[pt_idx](2);
}
//only load original data - no rotated
if(depth_path.parent_path().parent_path().filename().string() == "Depth" && (idx % this->param_.inc() == 0)) {
depth_paths_.push_back(depth_path);
annos_.push_back(anno);
}
idx++;
}
this->max_idx_ = depth_paths_.size();
label_file.close();
std::cout << "[INFO] label file " << label_path << " contained " << depth_paths_.size() << " annotated depth images" << std::endl;
}
// Write the class attributes portion of ClassFile structure
// JVMSpec| u2 attributes_count;
// JVMSpec| attribute_info attributes[attributes_count];
void JvmtiClassFileReconstituter::write_class_attributes() {
u2 inner_classes_length = inner_classes_attribute_length();
Symbol* generic_signature = ikh()->generic_signature();
typeArrayHandle anno(thread(), ikh()->class_annotations());
int attr_count = 0;
if (generic_signature != NULL) {
++attr_count;
}
if (ikh()->source_file_name() != NULL) {
++attr_count;
}
if (ikh()->source_debug_extension() != NULL) {
++attr_count;
}
if (inner_classes_length > 0) {
++attr_count;
}
if (anno.not_null()) {
++attr_count; // has RuntimeVisibleAnnotations attribute
}
write_u2(attr_count);
if (generic_signature != NULL) {
write_signature_attribute(symbol_to_cpool_index(generic_signature));
}
if (ikh()->source_file_name() != NULL) {
write_source_file_attribute();
}
if (ikh()->source_debug_extension() != NULL) {
write_source_debug_extension_attribute();
}
if (inner_classes_length > 0) {
write_inner_classes_attribute(inner_classes_length);
}
if (anno.not_null()) {
write_annotations_attribute("RuntimeVisibleAnnotations", anno);
}
}
// Write the field information portion of ClassFile structure
// JVMSpec| u2 fields_count;
// JVMSpec| field_info fields[fields_count];
void JvmtiClassFileReconstituter::write_field_infos() {
HandleMark hm(thread());
objArrayHandle fields_anno(thread(), ikh()->fields_annotations());
// Compute the real number of Java fields
int java_fields = ikh()->java_fields_count();
write_u2(java_fields);
for (JavaFieldStream fs(ikh()); !fs.done(); fs.next()) {
AccessFlags access_flags = fs.access_flags();
int name_index = fs.name_index();
int signature_index = fs.signature_index();
int initial_value_index = fs.initval_index();
guarantee(name_index != 0 && signature_index != 0, "bad constant pool index for field");
// int offset = ikh()->field_offset( index );
int generic_signature_index = fs.generic_signature_index();
typeArrayHandle anno(thread(), fields_anno.not_null() ?
(typeArrayOop)(fields_anno->obj_at(fs.index())) :
(typeArrayOop)NULL);
// JVMSpec| field_info {
// JVMSpec| u2 access_flags;
// JVMSpec| u2 name_index;
// JVMSpec| u2 descriptor_index;
// JVMSpec| u2 attributes_count;
// JVMSpec| attribute_info attributes[attributes_count];
// JVMSpec| }
write_u2(access_flags.as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS);
write_u2(name_index);
write_u2(signature_index);
int attr_count = 0;
if (initial_value_index != 0) {
++attr_count;
}
if (access_flags.is_synthetic()) {
// ++attr_count;
}
if (generic_signature_index != 0) {
++attr_count;
}
if (anno.not_null()) {
++attr_count; // has RuntimeVisibleAnnotations attribute
}
write_u2(attr_count);
if (initial_value_index != 0) {
write_attribute_name_index("ConstantValue");
write_u4(2); //length always 2
write_u2(initial_value_index);
}
if (access_flags.is_synthetic()) {
// write_synthetic_attribute();
}
if (generic_signature_index != 0) {
write_signature_attribute(generic_signature_index);
}
if (anno.not_null()) {
write_annotations_attribute("RuntimeVisibleAnnotations", anno);
}
}
}
// Write one method_info structure
// JVMSpec| method_info {
// JVMSpec| u2 access_flags;
// JVMSpec| u2 name_index;
// JVMSpec| u2 descriptor_index;
// JVMSpec| u2 attributes_count;
// JVMSpec| attribute_info attributes[attributes_count];
// JVMSpec| }
void JvmtiClassFileReconstituter::write_method_info(methodHandle method) {
AccessFlags access_flags = method->access_flags();
constMethodHandle const_method(thread(), method->constMethod());
u2 generic_signature_index = const_method->generic_signature_index();
typeArrayHandle anno(thread(), method->annotations());
typeArrayHandle param_anno(thread(), method->parameter_annotations());
typeArrayHandle default_anno(thread(), method->annotation_default());
write_u2(access_flags.get_flags() & JVM_RECOGNIZED_METHOD_MODIFIERS);
write_u2(const_method->name_index());
write_u2(const_method->signature_index());
// write attributes in the same order javac does, so we can test with byte for
// byte comparison
int attr_count = 0;
if (const_method->code_size() != 0) {
++attr_count; // has Code attribute
}
if (const_method->has_checked_exceptions()) {
++attr_count; // has Exceptions attribute
}
if (default_anno.not_null()) {
++attr_count; // has AnnotationDefault attribute
}
// Deprecated attribute would go here
if (access_flags.is_synthetic()) { // FIXME
// ++attr_count;
}
if (generic_signature_index != 0) {
++attr_count;
}
if (anno.not_null()) {
++attr_count; // has RuntimeVisibleAnnotations attribute
}
if (param_anno.not_null()) {
++attr_count; // has RuntimeVisibleParameterAnnotations attribute
}
write_u2(attr_count);
if (const_method->code_size() > 0) {
write_code_attribute(method);
}
if (const_method->has_checked_exceptions()) {
write_exceptions_attribute(const_method);
}
if (default_anno.not_null()) {
write_annotations_attribute("AnnotationDefault", default_anno);
}
// Deprecated attribute would go here
if (access_flags.is_synthetic()) {
// write_synthetic_attribute();
}
if (generic_signature_index != 0) {
write_signature_attribute(generic_signature_index);
}
if (anno.not_null()) {
write_annotations_attribute("RuntimeVisibleAnnotations", anno);
}
if (param_anno.not_null()) {
write_annotations_attribute("RuntimeVisibleParameterAnnotations", param_anno);
}
}
// Write the field information portion of ClassFile structure
// JVMSpec| u2 fields_count;
// JVMSpec| field_info fields[fields_count];
void JvmtiClassFileReconstituter::write_field_infos() {
HandleMark hm(thread());
typeArrayHandle fields(thread(), ikh()->fields());
int fields_length = fields->length();
int num_fields = fields_length / instanceKlass::next_offset;
objArrayHandle fields_anno(thread(), ikh()->fields_annotations());
write_u2(num_fields);
for (int index = 0; index < fields_length; index += instanceKlass::next_offset) {
AccessFlags access_flags;
int flags = fields->ushort_at(index + instanceKlass::access_flags_offset);
access_flags.set_flags(flags);
int name_index = fields->ushort_at(index + instanceKlass::name_index_offset);
int signature_index = fields->ushort_at(index + instanceKlass::signature_index_offset);
int initial_value_index = fields->ushort_at(index + instanceKlass::initval_index_offset);
guarantee(name_index != 0 && signature_index != 0, "bad constant pool index for field");
int offset = ikh()->offset_from_fields( index );
int generic_signature_index =
fields->ushort_at(index + instanceKlass::generic_signature_offset);
typeArrayHandle anno(thread(), fields_anno.not_null() ?
(typeArrayOop)(fields_anno->obj_at(index / instanceKlass::next_offset)) :
(typeArrayOop)NULL);
// JVMSpec| field_info {
// JVMSpec| u2 access_flags;
// JVMSpec| u2 name_index;
// JVMSpec| u2 descriptor_index;
// JVMSpec| u2 attributes_count;
// JVMSpec| attribute_info attributes[attributes_count];
// JVMSpec| }
write_u2(flags & JVM_RECOGNIZED_FIELD_MODIFIERS);
write_u2(name_index);
write_u2(signature_index);
int attr_count = 0;
if (initial_value_index != 0) {
++attr_count;
}
if (access_flags.is_synthetic()) {
// ++attr_count;
}
if (generic_signature_index != 0) {
++attr_count;
}
if (anno.not_null()) {
++attr_count; // has RuntimeVisibleAnnotations attribute
}
write_u2(attr_count);
if (initial_value_index != 0) {
write_attribute_name_index("ConstantValue");
write_u4(2); //length always 2
write_u2(initial_value_index);
}
if (access_flags.is_synthetic()) {
// write_synthetic_attribute();
}
if (generic_signature_index != 0) {
write_signature_attribute(generic_signature_index);
}
if (anno.not_null()) {
write_annotations_attribute("RuntimeVisibleAnnotations", anno);
}
}
}
