龙书D3D11章节习题答案(第七章)

最新推荐文章于 2022-03-11 17:38:56 发布
最新推荐文章于 2022-03-11 17:38:56 发布
阅读量2.8k 收藏 4
点赞数 2
分类专栏： D3D11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tjj00686/article/details/51327370
版权
这篇博客介绍了如何修改D3D11光照演示程序，实现不同颜色的灯光效果，包括将方向光、点光源和聚光灯分别设置为红色、绿色和蓝色。同时，探讨了材质的光泽度对表面的影响，通过改变specular power观察不同光泽度对水面的反射效果。此外，实现了卡通着色效果，通过离散函数处理ks和kd实现颜色突变。最后，增加了聚光灯角度调整功能，响应用户键盘输入。
摘要由CSDN通过智能技术生成

以下答案仅供参考，有错欢迎留言。


Chapter 7 : Lighting

这一章的内容相对来说比较简单，没有什么复杂的步骤，但也需要多尝试得到不同的视觉效果。


1. Modify the lighting demo of this chapter so that the directional light only emits red light, the point light only emits
green light, and the spotlight only emits blue light. Using colored lights can be useful for different game moods;
for example, a red light might be used to signify emergency situations.


在LightApp::LightApp中按要求修改mDirLight, mPointLight, mSpotLight的值即可，具体改哪些要根据实际情况。

例如，修改方向光为红光，是修改ambient为红光还是修改diffuse为红光，还是specular？

视觉效果上，ambient设为红光，山岭红色要深很多且比较均匀，而且拖动鼠标左键绕y轴旋转场景时，山岭的所有面都是红的(原色为绿色)。

再把ambient改回为原先的值，试试设置diffuse为红光，这时由于漫反射还需要根据郎伯余弦定律来决定每个方向反射回光的强度，所以拖动鼠标左键绕y轴旋转场景时，山背向的一面仍然是绿的，且红光照射到的部分红色显然是扩散开的，非均匀，显然修改diffuse比较有现实感，而diffuse呢则次要一点，你如果想把整个场景调得更红一点就可以改diffuse为淡红色。

而specular的值呢，对山岭这样的粗糙表面没什么影响，但影响到光照射到水面上反射过来的颜色，所以还需要specular模拟光照在水面上的效果。

只修改diffuse为红光的效果图如下：


最低0.47元/天 解锁文章
独饮月色的猫
关注
专栏目录
编译原理龙书答案
05-13
编译原理龙书答案 完整性高 第二章 2.2 Exercises for Section 2.2 2.2.1 Consider the context-free grammar: S -> S S + | S S * | a Show how the string aa+a* can be generated by this grammar. Construct a parse tree for this string. What language does this grammar generate? Justify your answer. answer S -> S S * -> S S + S * -> a S + S * -> a a + S * -> a a + a * L = {Postfix expression consisting of digits, plus and multiple signs} 2.2.2 What language is generated by the following grammars? In each case justify your answer. S -> 0 S 1 | 0 1 S -> + S S | - S S | a S -> S ( S ) S | ε S -> a S b S | b S a S | ε ⧗ S -> a | S + S | S S | S * | ( S ) answer L = {0n1n | n>=1} L = {Prefix expression consisting of plus and minus signs} L = {Matched brackets of arbitrary arrangement and nesting, includes ε} L = {String has the same amount of a and b, includes ε} ？ 2.2.3 Which of the grammars in Exercise 2.2.2 are ambiguous answer No No Yes Yes Yes 2.2.4 Construct unambiguous context-free grammars for each of the following languages. In each case show that your grammar is correct. Arithmetic expressions in postfix notation. Left-associative lists of identifiers separated by commas. Right-associative lists of identifiers separated by commas. Arithmetic expressions of integers and identifiers with the four binary operators +, - , *, /. answer 1. E -> E E op | num 2. list -> list , id | id 3. list -> id , list | id 4. expr -> expr + term | expr - term | term term -> term * factor | term / factor | factor factor -> id | num | (expr) 5. expr -> expr + term | expr - term | term term -> term * unary | term / unary | unary unary -> + factor | - factor factor - > id | num | (expr) 2.2.5 Show that all binary strings generated by the following grammar have values divisible by 3. Hint. Use induction on the number of nodes in a parse tree. num -> 11 | 1001 | num 0 | num num Does the grammar generate all binary strings with values divisible by 3? answer prove any string derived from the grammar can be considered to be a sequence consisting of 11, 1001 and 0, and not prefixed with 0. the sum of this string is: sum = Σn (21 + 20) * 2 n + Σm (23 + 20) * 2m = Σn 3 * 2 n + Σm 9 * 2m It is obviously can divisible by 3. No. Consider string "10101", it is divisible by 3, but cannot derived from the grammar. Question: any general prove? 2.2.6 Construct a context-free grammar for roman numerals. Note: we just consider a subset of roman numerals which is less than 4k. answer wikipedia: Roman_numerals via wikipedia, we can categorize the single noman numerals into 4 groups: I, II, III | I V | V, V I, V II, V III | I X then get the production: digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε and we can find a simple way to map roman to arabic numerals. For example: XII => X, II => 10 + 2 => 12 CXCIX => C, XC, IX => 100 + 90 + 9 => 199 MDCCCLXXX => M, DCCC, LXXX => 1000 + 800 + 80 => 1880 via the upper two rules, we can derive the production: romanNum -> thousand hundred ten digit thousand -> M | MM | MMM | ε hundred -> smallHundred | C D | D smallHundred | C M smallHundred -> C | CC | CCC | ε ten -> smallTen | X L | L smallTen | X C smallTen -> X | XX | XXX | ε digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε 2.3 Exercises for Section 2.3 2.3.1 Construct a syntax-directed translation scheme that trans­ lates arithmetic expressions from infix notation into prefix notation in which an operator appears before its operands; e.g. , -xy is the prefix notation for x - y . Give annotated parse trees for the inputs 9-5+2 and 9-5*2.。 answer productions: expr -> expr + term | expr - term | term term -> term * factor | term / factor | factor factor -> digit | (expr) translation schemes: expr -> {print("+")} expr + term | {print("-")} expr - term | term term -> {print("*")} term * factor | {print("/")} term / factor | factor factor -> digit {print(digit)} | (expr) 2.3.2 Construct a syntax-directed translation scheme that trans­ lates arithmetic expressions from postfix notation into infix notation. Give annotated parse trees for the inputs 95-2* and 952*-. answer productions: expr -> expr expr + | expr expr - | expr expr * | expr expr / | digit translation schemes: expr -> expr {print("+")} expr + | expr {print("-")} expr - | {print("(")} expr {print(")*(")} expr {print(")")} * | {print("(")} expr {print(")/(")} expr {print(")")} / | digit {print(digit)} Another reference answer E -> {print("(")} E {print(op)} E {print(")"}} op | digit {print(digit)} 2.3.3 Construct a syntax-directed translation scheme that trans­ lates integers into roman numerals answer assistant function: repeat(sign, times) // repeat('a',2) = 'aa' translation schemes: num -> thousand hundred ten digit { num.roman = thousand.roman || hundred.roman || ten.roman || digit.roman; print(num.roman)} thousand -> low {thousand.roman = repeat('M', low.v)} hundred -> low {hundred.roman = repeat('C', low.v)} | 4 {hundred.roman = 'CD'} | high {hundred.roman = 'D' || repeat('X', high.v - 5)} | 9 {hundred.roman = 'CM'} ten -> low {ten.roman = repeat('X', low.v)} | 4 {ten.roman = 'XL'} | high {ten.roman = 'L' || repeat('X', high.v - 5)} | 9 {ten.roman = 'XC'} digit -> low {digit.roman = repeat('I', low.v)} | 4 {digit.roman = 'IV'} | high {digit.roman = 'V' || repeat('I', high.v - 5)} | 9 {digit.roman = 'IX'} low -> 0 {low.v = 0} | 1 {low.v = 1} | 2 {low.v = 2} | 3 {low.v = 3} high -> 5 {high.v = 5} | 6 {high.v = 6} | 7 {high.v = 7} | 8 {high.v = 8} 2.3.4 Construct a syntax-directed translation scheme that trans­ lates roman numerals into integers. answer productions: romanNum -> thousand hundred ten digit thousand -> M | MM | MMM | ε hundred -> smallHundred | C D | D smallHundred | C M smallHundred -> C | CC | CCC | ε ten -> smallTen | X L | L smallTen | X C smallTen -> X | XX | XXX | ε digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε translation schemes: romanNum -> thousand hundred ten digit {romanNum.v = thousand.v || hundred.v || ten.v || digit.v; print(romanNun.v)} thousand -> M {thousand.v = 1} | MM {thousand.v = 2} | MMM {thousand.v = 3} | ε {thousand.v = 0} hundred -> smallHundred {hundred.v = smallHundred.v} | C D {hundred.v = smallHundred.v} | D smallHundred {hundred.v = 5 + smallHundred.v} | C M {hundred.v = 9} smallHundred -> C {smallHundred.v = 1} | CC {smallHundred.v = 2} | CCC {smallHundred.v = 3} | ε {hundred.v = 0} ten -> smallTen {ten.v = smallTen.v} | X L {ten.v = 4} | L smallTen {ten.v = 5 + smallTen.v} | X C {ten.v = 9} smallTen -> X {smallTen.v = 1} | XX {smallTen.v = 2} | XXX {smallTen.v = 3} | ε {smallTen.v = 0} digit -> smallDigit {digit.v = smallDigit.v} | I V {digit.v = 4} | V smallDigit {digit.v = 5 + smallDigit.v} | I X {digit.v = 9} smallDigit -> I {smallDigit.v = 1} | II {smallDigit.v = 2} | III {smallDigit.v = 3} | ε {smallDigit.v = 0} 2.3.5 Construct a syntax-directed translation scheme that trans­ lates postfix arithmetic expressions into equivalent prefix arithmetic expressions. answer production: expr -> expr expr op | digit translation scheme: expr -> {print(op)} expr expr op | digit {print(digit)} Exercises for Section 2.4 2.4.1 Construct recursive-descent parsers, starting with the follow­ ing grammars: S -> + S S | - S S | a S -> S ( S ) S | ε S -> 0 S 1 | 0 1 Answer 1） S -> + S S | - S S | a void S(){ switch(lookahead){ case "+": match("+"); S(); S(); break; case "-": match("-"); S(); S(); break; case "a": match("a"); break; default: throw new SyntaxException(); } } void match(Terminal t){ if(lookahead = t){ lookahead = nextTerminal(); }else{ throw new SyntaxException() } } 2） S -> S ( S ) S | ε void S(){ if(lookahead == "("){ S(); match("("); S(); match(")"); S(); } } 3） S -> 0 S 1 | 0 1 void S(){ switch(lookahead){ case "0": match("0"); S(); match("1"); break; case "1": // match(epsilon); break; default: throw new SyntaxException(); } } Exercises for Section 2.6 2.6.1 Extend the lexical analyzer in Section 2.6.5 to remove com­ ments, defined as follows: A comment begins with // and includes all characters until the end of that line. A comment begins with /* and includes all characters through the next occurrence of the character sequence */. 2.6.2 Extend the lexical analyzer in Section 2.6.5 to recognize the relational operators <, =, >. 2.6.3 Extend the lexical analyzer in Section 2.6.5 to recognize float­ ing point numbers such as 2., 3.14, and . 5. Answer Source code: commit 8dd1a9a Code snippet(src/lexer/Lexer.java)： public Token scan() throws IOException, SyntaxException{ for(;;peek = (char)stream.read()){ if(peek == ' ' || peek == '\t'){ continue; }else if(peek == '\n'){ line = line + 1; }else{ break; } } // handle comment if(peek == '/'){ peek = (char) stream.read(); if(peek == '/'){ // single line comment for(;;peek = (char)stream.read()){ if(peek == '\n'){ break; } } }else if(peek == '*'){ // block comment char prevPeek = ' '; for(;;prevPeek = peek, peek = (char)stream.read()){ if(prevPeek == '*' && peek == '/'){ break; } } }else{ throw new SyntaxException(); } } // handle relation sign if("".indexOf(peek) > -1){ StringBuffer b = new StringBuffer(); b.append(peek); peek = (char)stream.read(); if(peek == '='){ b.append(peek); } return new Rel(b.toString()); } // handle number, no type sensitive if(Character.isDigit(peek) || peek == '.'){ Boolean isDotExist = false; StringBuffer b = new StringBuffer(); do{ if(peek == '.'){ isDotExist = true; } b.append(peek); peek = (char)stream.read(); }while(isDotExist == true ? Character.isDigit(peek) : Character.isDigit(peek) || peek == '.'); return new Num(new Float(b.toString())); } // handle word if(Character.isLetter(peek)){ StringBuffer b = new StringBuffer(); do{ b.append(peek); peek = (char)stream.read(); }while(Character.isLetterOrDigit(peek)); String s = b.toString(); Word w = words.get(s); if(w == null){ w = new Word(Tag.ID, s); words.put(s, w); } return w; } Token t = new Token(peek); peek = ' '; return t; } Exercises for Section 2.8 2.8.1 For-statements in C and Java have the form: for ( exprl ; expr2 ; expr3 ) stmt The first expression is executed before the loop; it is typically used for initializ­ ing the loop index. The second expression is a test made before each iteration of the loop; the loop is exited if the expression becomes O. The loop itself can be thought of as the statement {stmt expr3 ; }. The third expression is executed at the end of each iteration; it is typically used to increment the loop index. The meaning of the for-statement is similar to expr1 ; while ( expr2 ) {stmt expr3 ; } Define a class For for for-statements, similar to class If in Fig. 2.43. Answer class For extends Stmt{ Expr E1; Expr E2; Expr E3; Stmt S; public For(Expr expr1, Expr expr2, Expr expr3, Stmt stmt){ E1 = expr1; E2 = expr2; E3 = expr3; S = stmt; } public void gen(){ E1.gen(); Label start = new Lable(); Lalel end = new Lable(); emit("ifFalse " + E2.rvalue().toString() + " goto " + end); S.gen(); E3.gen(); emit("goto " + start); emit(end + ":") } } 2.8.2 The programming language C does not have a boolean type. Show how a C compiler might translate an if-statement into three-address code. Answer Replace emit("isFalse " + E.rvalue().toString() + " goto " + after); with emit("ifNotEqual " + E.rvalue().toString() + " 0 goto " + after); or emit("isNotEqualZero " + E.rvalue().toString() + " goto " + after);
《编译原理-龙书》练习第7章
buck84的专栏
01-27 5195
7.1 存储组织 7.2 空间的栈式分配 7.2.4栈中的变长数据，在c语言中所有变长数据都在堆中。 7.2.1 1）这种情况下快排效果最差O（n*n） 2）栈中最多状态情况： P(1, 9) P(1, 8) ... P(1,2) P(1,1) 共9个 7.2.3  1）              f(5)                  f(4)
编译原理（龙书）：第七章部分题目参考答案
乔卿的博客
01-29 3096
目录 7.2.5 7.2.6 7.3.2 7.2.5 答：返回值为9，理由如下： 将a赋值为3，调用f(a,a)，则传递参数为x=3，y=3， 在函数体内部，x=x+1得到值为4，y=y+2得到值为5， 返回值为x+y，因此返回值为9。 7.2.6 答：由题意，得： int c=4; int *b=&c; int **a=&b; 调用f(c,b,a)之后，将c、b、a的值压栈，即作为传递参数，之后调用函数， 则在函数体内，x=4，py=b（指针），ppz
Frank D. Luna龙书第二版第7章习题1答案
09-05
Introduction to 3D Game Programming with DirectX 9.0c —— A Shader Approach第7章习题1的答案，只给了源码，使用方式参见ReadMe.txt文件。
第 7 章 编译原理
xy88115211的博客
01-04 323
编译过程 编译型：写完才能运行 解释型：写一句执行一句 词法：分析关键字有没有打对 语法：分析有没有语法错误    比如：if 后面括号完整 语义：只能发现部分的语义问题，机器检查不可能发现所有的问题 中间代码： 目标代码：可执行的代码，涉及到操作系统和底层硬件 有些编译不会产生可执行的代码，而是产生中间代码：比如JAVA，屏蔽不同系统，硬件的差异，从而实现跨平台   文
龙书第四章答案
01-23
本资源摘要信息对应的文件标题是"龙书第四章答案"，其中包含了编译原理第四章的答案，主要讲解了预测语法分析器的构建方法。下面将对此进行详细的解释和分析。 预测语法分析器的构建步骤： 1. 消除左递归 在构建...
Frank D. Luna龙书第二版第7章习题3答案
09-05
Introduction to 3D Game Programming with DirectX 9.0c —— A Shader Approach第7章习题3的答案，只给了源码，使用方式参见ReadMe.txt文件。
龙书 编译原理练习答案 第二版
03-16
尽管缺失了第9、10和11章的答案，但其他章节的习题解答仍能为读者提供大量实践指导。以下是这些知识点的详细介绍： 1. **词法分析**：lexer源码是编译器前端的关键部分，它将源代码转换为一系列的标记（tokens）。...
龙书D3DX12随书源码
10-06
《龙书D3DX12随书源码》是一份非常宝贵的编程学习资源，它针对的是DirectX 12(D3D12)图形库的高级应用，特别适合那些希望深入理解并掌握DirectX 12编程技术的开发者。D3D12是Microsoft为Windows操作系统开发的一个...
编译原理（紫龙书）第2版习题答案
Rikkaの博客
04-04 6245
转载于某大佬的github用来收藏https://github.com/fool2fish/dragon-book-exercise-answers
编译原理课后第七章答案
05-16
编译原理及实现第七章的课后答案 有详细的图文解说 简单易懂
Frank D. Luna龙书第二版第7章习题4答案
09-05
Introduction to 3D Game Programming with DirectX 9 0c A Shader Approach第7章习题4的答案 只给了源码 使用方式参见ReadMe txt文件
编译原理（龙书）答案第三章
04-20
编译原理龙书第三章的具体详细答案，很受用，，提供大家参考，谢谢
编译原理（龙书）部分答案
09-26
编译原理龙书部分答案，包含了前9章的部分课后习题
编译原理（紫龙书）
05-10
编译原理（龙书）本科教学版
编译原理龙书答案(MarkDown)
Doge的技术小屋
01-04 4057
https://codechina.csdn.net/mirrors/fool2fish/dragon-book-exercise-answers?utm_source=csdn_github_accelerator
编译原理-运行时刻环境 课后习题+笔记
菜鸡姜姜的博客
03-11 1153
运行时刻环境 来源：龙书（厚），南大课后作业 p283 7.2.4 Answer 我们不妨将 g 的调用者称为 h，并给各个空间标号。 h 创建了 0~ 2 号空间，g 创建了 3~6 号空间，f 创建了 7 号空间。 h 写入了 y 和指向 h 的控制链的值；g 写入了 j, x 和指向 g 的控制链的值（因为尚未运行到返回的时候，所以没有写入返回值）；f 写入了 i 和 f 的返回值。 如图所示，0~ 3 号空间属于 g 的活动记录，4~7 号空间属于 f 的活动记录。 知识点 活
编译原理——第七章
@CJZ啊的博客
06-03 5514
第七章    语义分析和中间代码的产生知识总结一、中间语言1、语法树 语法树，有向非循环图和后缀式表示源程序的自然层次结构2、后缀式中 缀式： a:=b*-c+b*-c后缀式：       a b c - * b c - * + =3、三地址代码表示一般形式    x：＝y op z 三地址语句的种类：4、语法制导翻译生成三地址代码  需要用到的量：(1)E.place表示存放E值的名字。 (2)...
编译原理龙书：第二章习题解答与语言分析
在龙书《编译原理》的第二章中，我们探讨了两个关于文法和语言生成的问题。首先，问题2.1考察了一个上下文无关文法： S→SS+|SS*|a a) 该文法能够生成符号串aa+a*。通过递归展开，我们可以看到S可以转换为aS+S*，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值