For a computer science class, this class doesn't do a lot of coding. The lectures are all math/concept-based, with the first half of the course primarily involving matrices, and the second half involving algebra and just knowing the concepts. Lectures are fairly engaging and he uses slides but they don't cover everything and he usually writes most things on whiteboard.
Discussion sessions are where all of the coding happens... except the TAs aren't really the best at explaining the code, since it's from an obscure JavaScript library made solely for this course, therefore there's not much outside help. I didn't know JavaScript before this class, and there was only a small effort to teach the basics, so I had to self-learn quite a bit. Like I mentioned, TAs don't explain the code that well and usually just show screenshots of code from slides and a few demos.
There's also a group project which involves 3 people and you can make anything as long as it has an advanced graphical feature. As for the tests, the midterm was fair, but the final was really hard and ended up tanking my grade to a B+. Major time crunch too. But overall the workload is doable, with only 3 graded assignments, two exams, and a group project. I'd recommend this course if you know javascript and matrices pretty well and need a course with an easy workload.

Professor Law is a very kind and passionate individual! Overall this class was fun but exams were difficult; linear algebra isn’t a prerequisite for this course and would definitely recommend you only take this class if you have taken linear algebra before, as the professor automatically assumes everyone has. There is also little to no practice material, so you really don’t know what to expect in the midterm or final. We were never tested on code but rather arcane mathematical calculations that you can’t find practice problems anywhere online nor in the book, so you really have to study all the equations he gives out during lecture on your own and in-depth, as they’re not straightforward. Grade distribution for this class was:

15% Assignments — 3 coding projects in OpenGL & Javascript. I would say it takes a whole day or two to complete them, and would recommend going to office hours for clarity since lecture doesn’t help (lectures tend to be conceptual and mathematical, covering no code at all)

20% Midterm — Involves mainly mathematical calculations & a few conceptual questions. Grade statistics were high (oddly enough) so there is no curve.

35% Final — Same as Midterm

30% Team Project — SUPER fun! You basically create a game or animation with 3-4 teammates whom you choose at the beginning of the quarter. There is a midway demo & final demo, and grading criteria is based on how many advanced computer graphics features you implement. It definitely is time consuming and hard to start, since it’s a blank canvas, but I found it really fun so I didn’t mind. I would also recommend going to TA office hours and looking back at assignments for help since we’re really not taught any code in lecture.

I thought this course provided a good introduction to computer graphics, though it was quite heavy on the conceptual side and less "practical" (don't expect to be working with modern graphical frameworks -- for the projects in the course, we had to use a simplified version of WebGL called tiny graphics for learning purposes). The projects were also cool but I ultimately didn't feel like I got a realistic sense of modern graphical programming.

For course content, the first half involves reviewing basic linear algebra matrix transformations and an introduction to each step of the graphics rendering pipeline (how a 3D scene gets rendered to a 2D image). The early projects are really simple and can be done in a few hours, especially if you attend the discussion sections where the TAs basically give a mini walkthrough of each assignment. The second half covers a wide array of topics like object lighting, texture mapping, and ray tracing, which made me really appreciate the complexity of the work involved in this field.

The professor is quite good at explaining the concepts in an easy to understand manner, and I was able to follow along his mathematical derivations without trouble even though I do not consider myself a math person by any means. It's clear he has had years of experience teaching this material because concepts are made intuitive through his explanations. Sometimes though he would go a bit fast (especially when we would start to fall behind) so the lecture recordings were great for those times.

What's strange about this class is that the exams involve a lot of math computations (they're simple, but still there's a lot to remember) but there's little to no practice material made available. So you should definitely try to get a copy of the older exams to practice as the professor likes to reuse questions. Also, a large part of your grade and the work in the class is your group project, which is graded based on features and creativity, so make sure to choose teams wisely and spend time on it.

Overall, not a bad class to take if you have any interest/curiosity in computer graphics. I can't speak for other professors in this course, but I definitely would recommend you taking it with Professor Law.

Prof Law was a nice guy. He does genuinely care about students' learning and tries his best to be helpful and answer questions. I enjoyed getting to know him as a person.

The class itself though was not what I expected- before I even took it I thought it would involve digital artwork, but no, it involves math and programming textures, shading, and the like. There was really not enough guidance for the assignments since we didn't even talk about programming in class.

The exams were math heavy and also related to comparing/contrasting methods- the midterm was fine but the final was a bit hard.

There's a group project too, and they graded it a bit harshly.

It's not too hard to get an A but I personally don't think this class was worth being one of my electives.

This course is about the mathematical concepts of computer graphics (matrix transformations and vectors) which is exclusively reviewed in lectures and expected to be known in exams. On the other hand you are sort of expected to learn on your own how to code graphic applications using the Tiny Graphics (a custom made game engine for this class).

Lectures are not terribly useful, but attendance is not required and they're recorded. The professor mostly reads the slides and sketches over them when needed. The lectures will somewhat help you grasp the intuition behind the concepts, and sporadically some example problems are solved, but that is often not enough to prepare you for finals.

Exams are particularly tough, and they cover concepts gone over in lecture, but in my opinion neither the lectures, the slides, or even the TA slides have enough useful material to prepare you well. If you take this class, make sure you find your own ways to practice problems. I had a hard time with exams in this class because I study by doing homework, but the homework in this class is never tested in exams. The exams only test your theoretical knowledge which the structure of the class is ill-formed to teach.

The group project is extremely fun, but the professor and TA's do not know how to properly grade it. A set of strict and fuzzy requirements are given, and it is up to their opinion whether you fulfilled the "fuzzy" requirements. Also, in my experience I the TAs were ill-prepared to answer questions about Tiny Graphics. They often answer the questions in general terms and in regards to the assignments, but their guidance in technical aspects of code about Tiny Graphics was barely ever useful.

All in all this class can be an easy A, but it is going to require you to invest a significant amount of self-study time. Also, if you're going to take this class, preferably convince some of your friends to take it as well so that you can tackle the group project together.

Overall lectures were good. The professor sometimes has a roundabout way of explaining relatively simple concepts and could spend quite a bit of time on each concept, which could be boring. However, it does make the pace of the course more bearable. I wish the course focused a bit more on the programming side of things since that's what I found most interesting. The homeworks were fun (GLSL shaders were a bit confusing since there was no syntax highlighting and the TAs didn't really go over it too well). I really liked working on the final project, although I found the whole Peerceptiv thing to be unnecessary. I think that just having classmates/TAs give suggestions during the demo would suffice. The exams were fine. I only wish that cheat sheets were allowed since there's quite a lot to remember.
Overall solid class, a bit more math-heavy than expected, and projects were fun.

Slides are crap. Many slides vaguely describe the concepts but do not explain them in detail. You need to pay attention in lecture and take good notes, if you don't have any graphics background. And that's hard to do in a 6-8 p.m. class.

Homework was fairly interesting, but they DO NOT prepare you for the midterm. You can figure out how to do the hw if you are sufficiently fluent in JS and read some library source code / example code. But the midterm was mostly linear algebra and calculation based. You need to know graphics knowledge which are implementation details that the homeworks do not sufficiently exercise.

Lectures: Engaging lecturer, paying attention will help you a lot on exams. Course pace can be dense and slow at times especially around the linear algebra parts, but is otherwise okay. He also raises his volume drastically every so often so it will jolt you with adrenaline to keep you awake
Assignments: Doable in 1 day or less
Midterm: The exam was all math calculations (matrices, normals etc.) except for one conceptual problem. Definitely try to get your grubby hands on some past exams if you want practice. TA slides also have examples.
Final: More recent exams (2022 onward) are more difficult than the older ones (pre-2020), so focus on practicing those. I definitely think there are also more bases to cover conceptually and mathematically, so pay attention in lecture and study equations carefully.
Final project: Try to find some friends to work with before enrolling for the class. Otherwise, you’ll have to try your luck with strangers.

I would not recommend this class. Overall, the lectures were very boring and it was hard to pay attention to, and the tests were on obscure equations that I instantly forgot after taking the exams. It felt like 2 separate classes: one part was coding in WebGL to create cool graphics, and the other part was random math equations for the exams.

Exams: There was a midterm and a final that are closed notes. He doesn't release the test questions or solutions because he reuses questions from previous exams. I found the exams extremely stupid because we had to memorize random equations and procedures on how to answer certain types of questions. If you want to do well, find previous exams.

Assignments: We had 4 assignments (the first was worth 0 points and just setting up your environment). They're coding assignments where you modify their starter code. They're reused every year and aren't too challenging. Some parts are confusing, but the TAs were very helpful during discussions and gave tips.

Group project: You code a graphics project with WebGL which is graded by the TAs (they're great). My group got 100% which definitely carried my grade. It's the best part of the class if you choose a good team and a fun project.

Projects and assignments are fun but the exams were stupid. We didn't have enough materials for the exams and the answers for study guide are hard to find (because no one wants to buy expensive textbook). The materials weren't that interesting to me and lectures are very dry