void D3DShaderObjectProvider::find_locations()
{
sampler_locations.clear();
texture_locations.clear();
uniform_buffer_locations.clear();
if (d3dcompiler_dll) // If the compiler is available, we must use it! This ensures compatility with the blob
{
ComPtr<ID3D11ShaderReflection> reflect;
HRESULT result = d3dreflect(bytecode.get_data(),bytecode.get_size(), IID_ID3D11ShaderReflection, (void**)reflect.output_variable());
D3DTarget::throw_if_failed("D3DReflect failed", result);
D3D11_SHADER_DESC desc;
result = reflect->GetDesc(&desc);
D3DTarget::throw_if_failed("D3DReflect.GetDesc failed", result);
for (UINT i = 0; i < desc.BoundResources; i++)
{
D3D11_SHADER_INPUT_BIND_DESC binding;
result = reflect->GetResourceBindingDesc(i, &binding);
D3DTarget::throw_if_failed("D3DReflect.GetResourceBindingDesc failed", result);
set_binding(binding);
}
}
else
{
DXBC_Reflect reflect(bytecode.get_data(),bytecode.get_size());
for (size_t cnt=0; cnt<reflect.binding.size(); cnt++)
{
set_binding(reflect.binding[cnt]);
}
}
}
void
eval_product(void)
{
int i, j, k;
// 1st arg (quoted)
X = cadr(p1);
if (!issymbol(X))
stop("product: 1st arg?");
// 2nd arg
push(caddr(p1));
eval();
j = pop_integer();
if (j == (int) 0x80000000)
stop("product: 2nd arg?");
// 3rd arg
push(cadddr(p1));
eval();
k = pop_integer();
if (k == (int) 0x80000000)
stop("product: 3rd arg?");
// 4th arg
// fix
p1 = cddddr(p1);
p1 = car(p1);
B = get_binding(X);
A = get_arglist(X);
push_integer(1);
for (i = j; i <= k; i++) {
push_integer(i);
I = pop();
set_binding(X, I);
push(p1);
eval();
multiply();
}
set_binding_and_arglist(X, B, A);
}
void
eval_f(double t)
{
// These must be volatile or it crashes. (Compiler error?)
// Read it backwards, save_tos is a volatile int, etc.
int volatile save_tos;
U ** volatile save_frame;
save();
save_tos = tos;
save_frame = frame;
draw_flag++;
if (setjmp(draw_stop_return)) {
tos = save_tos;
push(symbol(NIL));
frame = save_frame;
restore();
draw_flag--;
return;
}
push_double(t);
p1 = pop();
set_binding(T, p1);
push(F);
eval();
yyfloat();
eval();
restore();
draw_flag--;
}
void
top_level_eval(void)
{
save();
trigmode = 0;
p1 = symbol(AUTOEXPAND);
if (iszero(get_binding(p1)))
expanding = 0;
else
expanding = 1;
p1 = pop();
push(p1);
eval();
p2 = pop();
// "draw", "for" and "setq" return "nil", there is no result to print
if (p2 == symbol(NIL)) {
push(p2);
restore();
return;
}
// update "last"
set_binding(symbol(LAST), p2);
if (!iszero(get_binding(symbol(BAKE)))) {
push(p2);
bake();
p2 = pop();
}
// If we evaluated the symbol "i" or "j" and the result was sqrt(-1)
// then don't do anything.
// Otherwise if "j" is an imaginary unit then subst.
// Otherwise if "i" is an imaginary unit then subst.
if ((p1 == symbol(SYMBOL_I) || p1 == symbol(SYMBOL_J))
&& isimaginaryunit(p2))
;
else if (isimaginaryunit(get_binding(symbol(SYMBOL_J)))) {
push(p2);
push(imaginaryunit);
push_symbol(SYMBOL_J);
subst();
p2 = pop();
} else if (isimaginaryunit(get_binding(symbol(SYMBOL_I)))) {
push(p2);
push(imaginaryunit);
push_symbol(SYMBOL_I);
subst();
p2 = pop();
}
#ifndef LINUX
// if we evaluated the symbol "a" and got "b" then print "a=b"
// do not print "a=a"
if (issymbol(p1) && !iskeyword(p1) && p1 != p2 && test_flag == 0) {
push_symbol(SETQ);
push(p1);
push(p2);
list(3);
p2 = pop();
}
#endif
push(p2);
restore();
}
sexp eval_object(sexp object, sexp environment) {
tail_loop:
if (is_quote_form(object)) return quotation_text(object);
if (is_variable_form(object))
return get_variable_value(object, environment);
if (is_define_form(object)) {
/* sexp value = eval_object(definition_value(object), environment); */
/* add_binding(definition_variable(object), value, environment); */
/* return value; */
return eval_object(define2set(object), environment);
}
if (is_assignment_form(object)) {
sexp value = eval_object(assignment_value(object), environment);
set_binding(assignment_variable(object), value, environment);
return value;
}
if (is_if_form(object)) {
sexp test_part = if_test_part(object);
sexp then_part = if_then_part(object);
sexp else_part = if_else_part(object);
if (!is_false(eval_object(test_part, environment))) {
object = then_part;
} else {
object = else_part;
}
goto tail_loop;
}
if (is_lambda_form(object)) {
sexp parameters = lambda_parameters(object);
sexp body = lambda_body(object);
return make_lambda_procedure(parameters, body, environment);
}
if (is_begin_form(object)) {
return eval_begin(object, environment);
}
if (is_cond_form(object)) {
object = cond2if(object);
goto tail_loop;
}
if (is_let_form(object)) {
object = let2lambda(object);
goto tail_loop;
}
if (is_and_form(object)) {
sexp tests = and_tests(object);
if (is_null(tests))
return make_true();
while (is_pair(pair_cdr(tests))) {
sexp result = eval_object(pair_car(tests), environment);
if (is_false(result))
return make_false();
tests = pair_cdr(tests);
}
return eval_object(pair_car(tests), environment);
}
if (is_or_form(object)) {
sexp tests = or_tests(object);
if (is_null(tests))
return make_false();
while (is_pair(pair_cdr(tests))) {
sexp result = eval_object(pair_car(tests), environment);
if (!is_false(result))
return result;
tests = pair_cdr(tests);
}
return eval_object(pair_car(tests), environment);
}
if (is_macro_form(object)) {
sexp pars = macro_parameters(object);
sexp body = macro_body(object);
return make_macro_procedure(pars, body, environment);
}
if (is_application_form(object)) {
sexp operator = application_operator(object);
sexp operands = application_operands(object);
operator = eval_object(operator, environment);
if (!is_function(operator) && !is_macro(operator)) {
fprintf(stderr, "Illegal functional object ");
write_object(operator, make_file_out_port(stderr));
fprintf(stderr, " from ");
write_object(pair_car(object), make_file_out_port(stderr));
fputc('\n', stderr);
exit(1);
}
/* Expand the macro before evaluating arguments */
if (is_macro(operator)) {
sexp body = macro_proc_body(operator);
sexp vars = macro_proc_pars(operator);
sexp def_env = macro_proc_env(operator);
sexp object = make_pair(S("begin"), body);
sexp env = extend_environment(vars, operands, def_env);
sexp exp = eval_object(object, env);
return eval_object(exp, environment);
}
operands = eval_arguments(operands, environment);
/* if (is_apply(operator)) { */
/* operator = pair_car(operands); */
/* operands = apply_operands_conc(pair_cdr(operands)); */
/* } */
if (is_eval(operator)) {
environment = pair_cadr(operands);
object = pair_car(operands);
goto tail_loop;
}
return eval_application(operator, operands);
} else return object;
}
